/// <summary>
/// Performs the first step in the OAuth2 workflow and retreives the auth code
/// </summary>
/// <param name="authCodeUri">The box api uri to retrieve the auth code. BoxConfig.AuthCodeUri should be used for this field</param>
/// <param name="redirectUri">The redirect uri that the page will navigate to after granting the auth code</param>
/// <returns></returns>
public static async Task<string> GetAuthCode(Uri authCodeUri, Uri redirectUri = null)
{
Uri callbackUri = redirectUri == null ?
WebAuthenticationBroker.GetCurrentApplicationCallbackUri() :
redirectUri;
WebAuthenticationResult war = await WebAuthenticationBroker.AuthenticateAsync(
WebAuthenticationOptions.None,
authCodeUri,
callbackUri);
switch (war.ResponseStatus)
{
case WebAuthenticationStatus.Success:
// grab auth code
var response = war.ResponseData;
WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(new Uri(response).Query);
return decoder.GetFirstValueByName("code");
case WebAuthenticationStatus.UserCancel:
throw new Exception("User Canceled Login");
case WebAuthenticationStatus.ErrorHttp:
default:
throw new Exception("Error returned by GetAuthCode() : " + war.ResponseStatus.ToString());
}
}
private static IEnumerable<Uri> ExtractDownloadUrls(string source)
{
#if NETFX_CORE
string urlMap = new WwwFormUrlDecoder(source).GetFirstValueByName("url_encoded_fmt_stream_map");
#else
string urlMap = HttpUtility.ParseQueryString(source).Get("url_encoded_fmt_stream_map");
#endif
string[] splitByUrls = urlMap.Split(',');
foreach (string s in splitByUrls)
{
#if NETFX_CORE
var decoder = new WwwFormUrlDecoder(s);
string url = string.Format("{0}&fallback_host={1}&signature={2}",
decoder.GetFirstValueByName("url"),
decoder.GetFirstValueByName("fallback_host"),
decoder.GetFirstValueByName("sig"));
url = WebUtility.UrlDecode(url);
url = WebUtility.UrlDecode(url);
#else
var queries = HttpUtility.ParseQueryString(s);
string url = string.Format("{0}&fallback_host={1}&signature={2}", queries["url"], queries["fallback_host"], queries["sig"]);
url = HttpUtility.UrlDecode(url);
url = HttpUtility.UrlDecode(url);
#endif
yield return new Uri(url);
}
}
private async void WebViewer_NavigationCompleted(WebView sender, WebViewNavigationCompletedEventArgs args)
{
// Check if new location is redirect uri
if (args.Uri.AbsoluteUri.IndexOf(App.RedirectUri) == 0)
{
// Get parameters
var encoder = new WwwFormUrlDecoder(args.Uri.AbsoluteUri.Replace('#', '&')); // Replacing # with ? to make GetFirstValueByName() work
var accessToken = encoder.GetFirstValueByName("access_token");
var expires = encoder.GetFirstValueByName("expires");
if (!String.IsNullOrEmpty(accessToken))
{
// Success
App.AccessToken = accessToken;
App.Expires = expires;
Frame.GoBack();
var successDialog = new MessageDialog("Successfully logged in.", "Success!");
await successDialog.ShowAsync();
return;
}
// Show error message, if something went wrong
var errorDialog = new MessageDialog("Whoops, we could not log you in successfully. Sorry for that!", "Something went wrong...");
await errorDialog.ShowAsync();
Frame.GoBack();
}
}
public async Task<bool> Login()
{
var url = "https://github.com/login/oauth/authorize?client_id=" + Uri.EscapeDataString(ClientId) + "&redirect_uri=" + Uri.EscapeDataString(RedirectUri) + "&scope=repo&display=popup&response_type=token";
var startUri = new Uri(url);
var endUri = new Uri(RedirectUri);
var webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, startUri, endUri);
string code = "";
switch (webAuthenticationResult.ResponseStatus)
{
case WebAuthenticationStatus.Success:
var decoder = new WwwFormUrlDecoder(webAuthenticationResult.ResponseData.Replace(RedirectUri + "/?", ""));
code = decoder.First(x => x.Name == "code").Value;
break;
case WebAuthenticationStatus.ErrorHttp:
return false;
break;
default:
return false;
break;
}
var c = new HttpClient();
var data = new Dictionary<string, string>
{
{"client_id", ClientId},
{"client_secret", ClientSecret},
{"code", code}
};
var content = new FormUrlEncodedContent(data);
var request = await c.PostAsync(Accesstokenuri, content);
var result = await request.Content.ReadAsStringAsync();
_accessToken = new WwwFormUrlDecoder(result).GetFirstValueByName("access_token");
return true;
}
private async Task<Token> GetAccessToken()
{
var token = new Token();
var startUrl = Common.FormatAuthUrl(AuthorizationEndpointUrl, ResponseTypes.Token, ConsumerKey,
WebUtility.UrlEncode(CallbackUrl), DisplayTypes.Popup);
var startUri = new Uri(startUrl);
var endUri = new Uri(CallbackUrl);
var webAuthenticationResult =
await Windows.Security.Authentication.Web.WebAuthenticationBroker.AuthenticateAsync(
Windows.Security.Authentication.Web.WebAuthenticationOptions.None,
startUri,
endUri);
switch (webAuthenticationResult.ResponseStatus)
{
case Windows.Security.Authentication.Web.WebAuthenticationStatus.Success:
var responseData = webAuthenticationResult.ResponseData;
var responseUri = new Uri(responseData);
var decoder = new WwwFormUrlDecoder(responseUri.Fragment.Replace("#", "?"));
token.AccessToken = decoder.GetFirstValueByName("access_token");
token.RefreshToken = decoder.GetFirstValueByName("refresh_token");
token.InstanceUrl = WebUtility.UrlDecode(decoder.GetFirstValueByName("instance_url"));
return token;
case Windows.Security.Authentication.Web.WebAuthenticationStatus.ErrorHttp:
throw new Exception(webAuthenticationResult.ResponseErrorDetail.ToString());
default:
throw new Exception(webAuthenticationResult.ResponseData);
}
}
private bool TryGetCode(string query, out string code)
{
var decoder = new WwwFormUrlDecoder(query);
var entry = decoder.FirstOrDefault(e => e.Name == "code");
code = entry?.Value;
return entry != null;
}
private string ExtractCode(string redirectedUrl)
{
var url = new Uri(redirectedUrl);
var decoder = new WwwFormUrlDecoder(url.Query);
return decoder.GetFirstValueByName("code");
}
public MainWindow()
{
InitializeComponent();
var args = Environment.GetCommandLineArgs();
if (args.Length > 1)
{
Uri argUri;
if (Uri.TryCreate(args[1], UriKind.Absolute, out argUri))
{
var decoder = new WwwFormUrlDecoder(argUri.Query);
if (decoder.Any())
{
InputUrI.Text = string.Empty;
foreach (var entry in decoder)
{
InputUrI.Text += entry.Name + "=" + entry.Value + ",";
inputs[entry.Name] = entry.Value;
}
InputUrI.Text = InputUrI.Text.Remove(InputUrI.Text.Length - 1);
}
}
}
}
public static async Task<string> GetAccessToken(string username, string password)
{
try
{
var handler = new HttpClientHandler
{
AutomaticDecompression = DecompressionMethods.GZip,
AllowAutoRedirect = false
};
using (var tempHttpClient = new HttpClient(handler))
{
//Get session cookie
var sessionResp = await tempHttpClient.GetAsync(Resources.PtcLoginUrl);
var data = await sessionResp.Content.ReadAsStringAsync();
var lt = JsonHelper.GetValue(data, "lt");
var executionId = JsonHelper.GetValue(data, "execution");
//Login
var loginResp = await tempHttpClient.PostAsync(Resources.PtcLoginUrl,
new FormUrlEncodedContent(
new[]
{
new KeyValuePair<string, string>("lt", lt),
new KeyValuePair<string, string>("execution", executionId),
new KeyValuePair<string, string>("_eventId", "submit"),
new KeyValuePair<string, string>("username", username),
new KeyValuePair<string, string>("password", password)
}));
var decoder = new WwwFormUrlDecoder(loginResp.Headers.Location.Query);
var ticketId = decoder.GetFirstValueByName("ticket");
if (string.IsNullOrEmpty(ticketId))
throw new PtcOfflineException();
//Get tokenvar
var tokenResp = await tempHttpClient.PostAsync(Resources.PtcLoginOauth,
new FormUrlEncodedContent(
new[]
{
new KeyValuePair<string, string>("client_id", "mobile-app_pokemon-go"),
new KeyValuePair<string, string>("redirect_uri",
"https://www.nianticlabs.com/pokemongo/error"),
new KeyValuePair<string, string>("client_secret",
"w8ScCUXJQc6kXKw8FiOhd8Fixzht18Dq3PEVkUCP5ZPxtgyWsbTvWHFLm2wNY0JR"),
new KeyValuePair<string, string>("grant_type", "refresh_token"),
new KeyValuePair<string, string>("code", ticketId)
}));
var tokenData = await tokenResp.Content.ReadAsStringAsync();
decoder = new WwwFormUrlDecoder(tokenData);
return decoder.GetFirstValueByName("access_token");
}
}
catch (Exception)
{
return string.Empty;
}
}
public static string GetQueryParameter(this Uri uri, string parameterName)
{
string query = uri.Query;
if (query.Length <= 1)
{
return null;
}
WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(query);
return decoder.GetFirstValueByName(parameterName);
}
private async Task<string> GetTokenFromCode(string code)
{
var uri = $"{TokenUri}?client_id={Credentials.AppId}&client_secret={Credentials.AppSecret}&code={code}";
using (var client = new HttpClient())
{
var response = await client.PostAsync(uri, null);
var query = await response.Content.ReadAsStringAsync();
var decoder = new WwwFormUrlDecoder(query);
return decoder.GetFirstValueByName("access_token");
}
}
private static string ExtracktTicketFromResponse(HttpResponseMessage loginResp)
{
var location = loginResp.Headers.Location;
if (location == null)
throw new LoginFailedException(loginResp);
var decoder = new WwwFormUrlDecoder(loginResp.Headers.Location.Query);
var ticketId = decoder.GetFirstValueByName("ticket");
if (ticketId == null)
throw new PtcOfflineException();
return ticketId;
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (e.Parameter != null)
{
var args = e.Parameter as ProtocolActivatedEventArgs;
Uri uri = args.Uri;
WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(uri.ToString());
string customer = decoder[0].Value;
string price = decoder[1].Value;
Customer.Text = customer;
Price.Text = price;
}
}
public Splash(ProtocolActivatedEventArgs args)
: this(args.SplashScreen)
{
var _Decoder = new WwwFormUrlDecoder(args.Uri.Query);
var _Id = _Decoder.Where(q => q.Name.ToLower() == "module").Select(q => q.Value).FirstOrDefault();
if (string.IsNullOrWhiteSpace(_Id))
_Decoder.Where(q => q.Name.ToLower() == "episode").Select(q => q.Value).FirstOrDefault();
if (string.IsNullOrWhiteSpace(_Id))
{
Services.Navigation.GotoFail("The Uri specified was incorrect.");
return;
}
AllowResume = false;
GotoType = typeof(Views.Detail);
GotoParam = _Id;
}
public static async Task<ExternalLoginResult> GetExternalAccessTokenAsync(string externalLoginUri, bool silentMode = false)
{
Uri authorizationRequestUri = new Uri(new Uri(ClientFactory.BaseAddress), externalLoginUri);
WebAuthenticationOptions webAuthenticationOptions = silentMode ? WebAuthenticationOptions.SilentMode : WebAuthenticationOptions.None;
WebAuthenticationResult authenticationResult = await WebAuthenticationBroker.AuthenticateAsync(webAuthenticationOptions, authorizationRequestUri);
ExternalLoginResult loginExternalResult = new ExternalLoginResult() { WebAuthenticationResult = authenticationResult };
if (authenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
{
Uri responseDataUri = new Uri(authenticationResult.ResponseData);
string fragment = responseDataUri.Fragment;
if (fragment != null && fragment.Length > 0)
{
WwwFormUrlDecoder wwwFormUrlDecoder = new WwwFormUrlDecoder(fragment.Substring(1));
loginExternalResult.AccessToken = wwwFormUrlDecoder.GetFirstValueByName("access_token");
}
}
return loginExternalResult;
}
public async Task<bool> CompleteOAuthFlowAsync(string responseData)
{
// responseData value eg http://example.com/path?code=4cba03187d6cd6720217&state=6dfa60685ac94a29bdde2d9f3cbdce0e
var responseUri = new Uri(responseData);
var decoder = new WwwFormUrlDecoder(responseUri.Query);
var code = decoder.GetFirstValueByName("code");
var state = decoder.GetFirstValueByName("state");
string storedState = VaultManager.GetPassword(VaultStateResourceKey, VaultDefaultUnusedUserName);
if (storedState != state)
return false;
// We are storing the code to later be able to refresh the access token
VaultManager.Save(VaultTokenCodeResourceKey, VaultDefaultUnusedUserName, code);
bool ok = await AcquireAccessTokenAsync(code, state).ConfigureAwait(false); ;
return ok;
}
public static async Task<bool> authenticateUser()
{
String WordpressURL = "https://public-api.wordpress.com/oauth2/authorize?client_id=428&redirect_uri=http://127.0.0.1&response_type=code";
System.Uri StartUri = new Uri(WordpressURL, UriKind.RelativeOrAbsolute);
System.Uri EndUri = new Uri("http://127.0.0.1", UriKind.RelativeOrAbsolute);
WebAuthenticationResult WebAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, StartUri, EndUri);
if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
{
WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(WebAuthenticationResult.ResponseData.ToString());
string authtoken = decoder.First().Value;
string post_string = FormatPostRequest(authtoken);
var content = new StringContent(post_string);
var client = new System.Net.Http.HttpClient();
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
var responseTask = client.PostAsync("https://public-api.wordpress.com/oauth2/token", content);
var response = await responseTask;
string jsonresponse = await response.Content.ReadAsStringAsync();
user = JsonConvert.DeserializeObject<AuthenticatedUser>(jsonresponse);
ApplicationData.Current.LocalSettings.Values["AuthUser"] = Authenticator.user.access_token;
postStatus(user.access_token);
displayname = await userInfo(user.access_token);
Authenticator.displayname = displayname;
return true;
}
else if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.UserCancel)
{
return false;
}
else
{
return false;
}
}
public static Uri AddOrUpdateQuery(this Uri uri, string parameterName, string parameterValue)
{
List<KeyValuePair<string, string>> nameValueCollection = new List<KeyValuePair<string, string>>();
string query = uri.Query;
if (query == "?")
{
query = string.Empty;
}
if (query.Length > 0)
{
WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(query);
foreach (var nameValue in decoder)
{
nameValueCollection.Add(new KeyValuePair<string, string>(nameValue.Name, nameValue.Value));
}
}
parameterName = WebUtility.UrlEncode(parameterName);
parameterValue = WebUtility.UrlEncode(parameterValue);
bool exist = false;
for (int i = 0; i < nameValueCollection.Count; i++)
{
if (nameValueCollection[i].Key == parameterName)
{
nameValueCollection[i] = new KeyValuePair<string, string>(parameterName, parameterValue);
exist = true;
break;
}
}
if (exist == false)
{
nameValueCollection.Add(new KeyValuePair<string, string>(parameterName, parameterValue));
}
query = string.Join("&", nameValueCollection.Select(temp => temp.Key + "=" + temp.Value));
return new UriBuilder(uri)
{
Query = query
}.Uri;
}
/// <summary>
/// Gets a list of <see cref="VideoInfo"/>s for the specified URL.
/// </summary>
/// <param name="videoUrl">The URL of the YouTube video.</param>
/// <returns>A list of <see cref="VideoInfo"/>s that can be used to download the video.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="videoUrl"/> parameter is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="videoUrl"/> parameter is not a valid YouTube URL.</exception>
/// <exception cref="VideoNotAvailableException">The video is not available.</exception>
/// <exception cref="WebException">An error occurred while downloading the YouTube page html.</exception>
/// <exception cref="YoutubeParseException">The Youtube page could not be parsed.</exception>
public static IEnumerable<VideoInfo> GetDownloadUrls(string videoUrl,System.Net.WebProxy proxy, System.Text.Encoding enc)
{
if (videoUrl == null)
throw new ArgumentNullException("videoUrl");
videoUrl = NormalizeYoutubeUrl(videoUrl);
string pageSource = GetPageSource(videoUrl,proxy, enc);
string videoTitle = GetVideoTitle(pageSource);
string thumnailUrl = GetThumnailUrl(pageSource);
#if NETFX_CORE
string id = new WwwFormUrlDecoder(videoUrl).GetFirstValueByName("v");
#else
string id = HttpUtility.ParseQueryString(new Uri(videoUrl).Query)["v"];
#endif
string requestUrl = String.Format("http://www.youtube.com/get_video_info?&video_id={0}&el=detailpage&ps=default&eurl=&gl=US&hl=en", id);
string source = GetPageSource(requestUrl,proxy, enc);
try
{
IEnumerable<Uri> downloadUrls = ExtractDownloadUrls(source);
return GetVideoInfos(downloadUrls, videoTitle, thumnailUrl);
}
catch (Exception ex)
{
ThrowYoutubeParseException(ex);
}
if (IsVideoUnavailable(pageSource))
{
throw new VideoNotAvailableException();
}
// If everything else fails, throw a generic YoutubeParseException
ThrowYoutubeParseException(null);
return null; // Will never happen, but the compiler requires it
}
private void webView_LoadCompleted(object sender, NavigationEventArgs e)
{
if (e.Uri.AbsoluteUri.Contains("access_token")) {
WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(e.Uri.AbsoluteUri);
long uID = 0;
long.TryParse(decoder.GetFirstValueByName("user_id"), out uID);
storage.SetToken(
decoder.GetFirstValueByName(Constants.TokenMarker));
storage.SetCurrUserID(uID);
this.Frame.Navigate(typeof(MyProfile));
}
else {
progressRing.IsActive = false;
webView.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
}
protected override void OnActivated(IActivatedEventArgs args)
{
if (args.Kind == ActivationKind.Protocol)
{
var commandArgs = args as ProtocolActivatedEventArgs;
Windows.Foundation.WwwFormUrlDecoder decoder =
new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
var destination = decoder.GetFirstValueByName("LaunchContext");
string uriToLaunch = destination;
var uri = new Uri(uriToLaunch);
var success = Windows.System.Launcher.LaunchUriAsync(uri);
Application.Current.Exit();
// this.Suspending += OnSuspending;
}
// base.OnActivated(args);
}
private void TopicWebView_OnNavigationStarting(WebView sender, WebViewNavigationStartingEventArgs args)
{
if (args.Uri != null && args.Uri.AbsoluteUri.StartsWith(Strings.LocalUriPrefix))
{
args.Cancel = true;
if (args.Uri.AbsoluteUri.Contains("quote"))
{
var decoder = new WwwFormUrlDecoder(args.Uri.Query);
var postId = decoder.FirstOrDefault(x => x.Name == "postId")?.Value;
if (!string.IsNullOrEmpty(postId))
Loc.Topic.ShowEditorCommand.Execute(Loc.Topic.CurrentTopic.TopicNewPostUriForm + $"&numrep={postId}");
}
else
{
Debug.WriteLine("WW " + args.Uri.Query + "-- " + args.Uri + " -- " + args.Uri.AbsoluteUri);
string param = args.Uri.Query.Replace("?", "");
if (Loc.Main.ContextMessageCommand.CanExecute(param))
Loc.Main.ContextMessageCommand.Execute(param);
}
}
}
private static IEnumerable<VideoInfo> GetVideoInfos(string source)
{
var t = new WwwFormUrlDecoder(source);
var videoTitle = t.GetFirstValueByName("title");
var splitByUrls = t.GetFirstValueByName("url_encoded_fmt_stream_map").Split(',');
var videoInfos = new List<VideoInfo>();
foreach (var s in splitByUrls) {
var queries = new WwwFormUrlDecoder(s);
var url = queries.GetFirstValueByName("url");
var decoder = new WwwFormUrlDecoder(url.Substring(url.IndexOf('?')));
byte formatCode;
if (!Byte.TryParse(decoder.GetFirstValueByName("itag"), out formatCode)) continue;
var fallbackHost = WebUtility.UrlDecode(queries.GetFirstValueByName("fallback_host"));
var sig = WebUtility.UrlDecode(queries.GetFirstValueByName("sig"));
var item = VideoInfo.Defaults.SingleOrDefault(videoInfo => videoInfo.FormatCode == formatCode);
var info = item != null ? item.Clone() : new VideoInfo(formatCode);
info.DownloadUri = new Uri(url + "&fallback_host=" + fallbackHost + "&signature=" + sig);
info.Title = videoTitle;
videoInfos.Add(info);
}
return videoInfos;
}
public static void ParseArguments(string arguments)
{
if (string.IsNullOrEmpty(arguments))
{
return;
}
var decoder = new WwwFormUrlDecoder(arguments);
var city = decoder.FirstOrDefault(x => x.Name.Equals("city"));
var parkingLot = decoder.FirstOrDefault(x => x.Name.Equals("parkingLot"));
if (city != null && parkingLot != null)
{
Task.Run(async () =>
{
await ServiceLocator.Current.GetInstance<MainViewModel>().TrySelectParkingLotById(city.Value, parkingLot.Value);
});
}else if (city != null)
{
Task.Run(async () =>
{
await ServiceLocator.Current.GetInstance<MainViewModel>().TrySelectCityById(city.Value);
});
}
}
/// <summary>
/// Parses the GET parameters from the URL and loads them into the settings
/// </summary>
/// <param name="uri"></param>
public void ParseUriIntoSettings(Uri uri)
{
var decoder = new WwwFormUrlDecoder(uri.Query);
// Take the parameters from the URL and put it into Settings
foreach (WwwFormUrlDecoderEntry entry in decoder)
{
try
{
var field = typeof(AppSettings).GetField(entry.Name);
if (field.FieldType == typeof(int))
{
field.SetValue(App.Controller.XmlSettings, Convert.ToInt32(entry.Value));
}
else if(field.FieldType == typeof(CameraType) ||
field.FieldType == typeof(StorageProvider))
{
field.SetValue(App.Controller.XmlSettings, Enum.Parse(field.FieldType, entry.Value));
}
else
{
//if the field being saved is the alias, and the alias has changed, send a telemetry event
if(0 == field.Name.CompareTo("MicrosoftAlias") &&
0 != entry.Value.CompareTo(App.Controller.XmlSettings.MicrosoftAlias))
{
Dictionary<string, string> properties = new Dictionary<string, string> { { "Alias", entry.Value } };
App.Controller.TelemetryClient.TrackEvent("Alias Changed", properties);
}
field.SetValue(App.Controller.XmlSettings, entry.Value);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "WebHelper", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToParseUriIntoSettings", events);
}
}
}
private static IEnumerable<VideoInfo> GetVideoInfos(IEnumerable<Uri> downloadUrls, string videoTitle)
{
var downLoadInfos = new List<VideoInfo>();
foreach (Uri url in downloadUrls)
{
#if NETFX_CORE
string itag = new WwwFormUrlDecoder(url.Query).GetFirstValueByName("itag");
#else
string itag = HttpUtility.ParseQueryString(url.Query)["itag"];
#endif
// for this version, only get the download URL
byte formatCode = Byte.Parse(itag);
// Currently based on YouTube specifications (later we'll depend on the MIME type returned from the web request)
VideoInfo info = VideoInfo.Defaults.SingleOrDefault(videoInfo => videoInfo.FormatCode == formatCode);
if (info != null)
{
info.DownloadUrl = url.ToString();
info.Title = videoTitle;
}
else
{
info = new VideoInfo(formatCode);
}
downLoadInfos.Add(info);
}
return downLoadInfos;
}
async protected override void OnActivated(IActivatedEventArgs args)
{
Frame rootFrame = Window.Current.Content as Frame;
if (rootFrame == null)
{
CreateRootFrame();
if (!RootFrame.Navigate(typeof(MainPage)))
{
throw new Exception("Failed to create initial page");
}
Window.Current.Activate();
}
if (args.Kind == ActivationKind.Launch)
{
var toastArgs = args as LaunchActivatedEventArgs;
if (toastArgs == null)
{
return;
}
var arguments = JsonConvert.DeserializeObject <ToastNotificationArgs>(toastArgs.Arguments);
if (arguments.openBookmarks)
{
var bookmarkCommand = new NavigateToBookmarksCommand();
bookmarkCommand.Execute(null);
return;
}
if (arguments != null && arguments.openPrivateMessages)
{
var openPms = new NavigateToPrivateMessageListPageCommand();
openPms.Execute(null);
return;
}
}
//Find out if this is activated from a toast;
if (args.Kind == ActivationKind.ToastNotification)
{
//Get the pre-defined arguments and user inputs from the eventargs;
var toastArgs = args as ToastNotificationActivatedEventArgs;
if (toastArgs == null)
{
return;
}
var arguments = JsonConvert.DeserializeObject <ToastNotificationArgs>(toastArgs.Argument);
if (arguments != null && arguments.threadId > 0)
{
var bookmarkCommand = new NavigateToBookmarksCommand();
bookmarkCommand.Execute(arguments.threadId);
return;
}
var forumEntity = JsonConvert.DeserializeObject <ForumEntity>(toastArgs.Argument);
if (forumEntity != null)
{
var navigateCommand = new NavigateToThreadListPageCommandViaTile();
navigateCommand.Execute(forumEntity);
}
}
// Cortana
if (args.Kind == ActivationKind.VoiceCommand)
{
var commandArgs = args as VoiceCommandActivatedEventArgs;
HandleVoiceRequest(commandArgs);
}
if (args.Kind == ActivationKind.Protocol)
{
var commandArgs = args as ProtocolActivatedEventArgs;
Windows.Foundation.WwwFormUrlDecoder decoder =
new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
var destination = decoder.GetFirstValueByName("LaunchContext");
var jsonTest = WebUtility.UrlDecode(destination);
var arguments = JsonConvert.DeserializeObject <ToastNotificationArgs>(jsonTest);
if (arguments != null && arguments.threadId > 0)
{
var bookmarkCommand = new NavigateToBookmarksCommand();
bookmarkCommand.Execute(arguments.threadId);
return;
}
if (arguments != null && arguments.openPrivateMessages)
{
var openPms = new NavigateToPrivateMessageListPageCommand();
openPms.Execute(null);
return;
}
var forumEntity = JsonConvert.DeserializeObject <ForumEntity>(jsonTest);
if (forumEntity != null)
{
var navigateCommand = new NavigateToThreadListPageCommandViaTile();
navigateCommand.Execute(forumEntity);
}
}
//...
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used when the application is launched to open a specific file, to display
/// search results, and so forth.
/// </summary>
/// <param name="args">Details about the launch request and process.</param>
protected override async void OnLaunched(LaunchActivatedEventArgs args)
{
SuspensionManager.KnownTypes.Add(typeof(Catalog));
SuspensionManager.KnownTypes.Add(typeof(Cart));
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
//Associate the frame with a SuspensionManager key
SuspensionManager.RegisterFrame(rootFrame, "AppFrame");
if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
// Restore the saved session state only when appropriate
try
{
await SuspensionManager.RestoreAsync();
}
catch (SuspensionManagerException)
{
//Something went wrong restoring state.
//Assume there is no state and continue
}
}
if (!SuspensionManager.SessionState.ContainsKey(SuspensionManagerConstants.Catalog))
{
Window.Current.Content = new ExtendedSplash();
Window.Current.Activate();
var repository = ServiceLocator.Get<CatalogRepository>();
var catalog = await repository.GetCatalog();
SuspensionManager.SessionState.Add(SuspensionManagerConstants.Catalog, catalog);
}
if (!SuspensionManager.SessionState.ContainsKey(SuspensionManagerConstants.Cart))
{
SuspensionManager.SessionState.Add(SuspensionManagerConstants.Cart, new Cart());
}
var pushNotificationRegistration = ServiceLocator.Get<PushNotificationRegistrationService>();
pushNotificationRegistration.AcquirePushChannel();
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
if (!rootFrame.Navigate(typeof(GroupedItemsPage), "AllCategories"))
{
throw new Exception("Failed to create initial page");
}
}
if (!string.IsNullOrEmpty(args.Arguments))
{
var decoder = new WwwFormUrlDecoder(args.Arguments);
var category = decoder.Where(v => v.Name == "category").Select(v => v.Value).FirstOrDefault();
if (!string.IsNullOrEmpty(category))
{
// if category exists then its launched from a secondary tile.
rootFrame.Navigate(typeof (GroupDetailPage), category);
}
var cartParam = decoder.Where(v => v.Name == "cartId").Select(v => v.Value).FirstOrDefault();
long cartId;
if (long.TryParse(cartParam, out cartId))
{
// if cartId exists then its launched from a toast.
rootFrame.Navigate(typeof (CartPage), cartId);
}
}
// Ensure the current window is active
Window.Current.Activate();
}
/// <summary>
/// Parses the GET parameters from the URL and then uses them to log into OneDrive
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
public async Task ParseOneDriveUri(Uri uri)
{
var oneDrive = App.Controller.Storage as OneDrive;
if (oneDrive == null)
return;
try
{
var decoder = new WwwFormUrlDecoder(uri.Query);
foreach (WwwFormUrlDecoderEntry entry in decoder)
{
// codeUrl is the parameter that contains the URL that was pasted into the textbox on the OneDrive page
if (entry.Name.Equals("codeUrl"))
{
string codeUrl = WebUtility.UrlDecode(entry.Value);
var codeUri = new Uri(codeUrl);
var codeDecoder = new WwwFormUrlDecoder(codeUri.Query);
foreach (WwwFormUrlDecoderEntry subEntry in codeDecoder)
{
if (subEntry.Name.Equals("code"))
{
await oneDrive.Authorize(subEntry.Value);
break;
}
}
break;
}
else if (entry.Name.Equals("logout"))
{
await oneDrive.Logout();
}
}
}
catch (Exception ex)
{
// Log telemetry event about this exception
var events = new Dictionary<string, string> { { "WebHelper", ex.Message } };
App.Controller.TelemetryClient.TrackEvent("FailedToParseOneDriveUri", events);
}
}
/// <summary>
/// Invoked when the application is activated by some other means other than launching
/// </summary>
/// <param name="e">Event data for the event.</param>
protected override async void OnActivated(IActivatedEventArgs args)
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
this.DebugSettings.EnableFrameRateCounter = true;
}
#endif
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
if (args.Kind == ActivationKind.VoiceCommand)
{
try
{
// now get the parameters pased in
VoiceCommandActivatedEventArgs commandArgs = args as VoiceCommandActivatedEventArgs;
SpeechRecognitionResult speechRecognitionResult = commandArgs.Result;
string voiceCommandName = speechRecognitionResult.RulePath[0];
string textSpoken = speechRecognitionResult.Text;
IReadOnlyList <string> recognisedVoiceCommandPhrases;
System.Diagnostics.Debug.WriteLine("Voice CommandName: " + voiceCommandName);
System.Diagnostics.Debug.WriteLine("text Spoken: " + textSpoken);
switch (voiceCommandName)
{
case "readBook":
{
string bookName = this.SemanticInterpretation("bookName", speechRecognitionResult);
var folder = ApplicationData.Current.LocalFolder;
var subFolder = await folder.GetFolderAsync("books");
var files = await subFolder.GetFilesAsync();
foreach (StorageFile sf in files)
{
if (sf.DisplayName.Equals(bookName))
{
book = sf.Name;
break;
}
}
break;
}
default:
{
break;
}
} // end Switch(voiceCommandName)
System.Diagnostics.Debug.WriteLine("go to main page Now ");
}
catch (Exception)
{
MessageDialog msgDialog = new MessageDialog("Crashed");
await msgDialog.ShowAsync();
}
}
else if (args.Kind == ActivationKind.Protocol)
{
var commandArgs = args as ProtocolActivatedEventArgs;
Windows.Foundation.WwwFormUrlDecoder decoder = new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
var destination = decoder.GetFirstValueByName("LaunchContext");
}
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(EnterByVoice), args.PreviousExecutionState);
}
// Ensure the current window is active
Window.Current.Activate();
}
// return series ID
static string ParseIDFromBookLink(string link)
{
Uri uri = new Uri(SeverBaseUri, link);
var decoder = new WwwFormUrlDecoder(uri.Query);
return decoder.GetFirstValueByName("id");
}
static NovelPositionIdentifier ParseIDFromReadLink(string link)
{
var pos = new NovelPositionIdentifier();
Uri uri = new Uri(SeverBaseUri, link);
var decoder = new WwwFormUrlDecoder(uri.Query);
pos.ChapterId = decoder.GetFirstValueByName("chapterId");
pos.VolumeId = decoder.GetFirstValueByName("volId");
pos.SeriesId = decoder.GetFirstValueByName("bookId");
return pos;
}
/// <summary>
/// Parses the GET parameters from the URL and returns the parameters and values in a Dictionary
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
public Dictionary<string, string> ParseGetParametersFromUrl(Uri uri)
{
Dictionary<string, string> parameters = new Dictionary<string, string>();
var decoder = new WwwFormUrlDecoder(uri.Query);
foreach (WwwFormUrlDecoderEntry entry in decoder)
{
parameters.Add(entry.Name, entry.Value);
}
return parameters;
}
