Parse.Phone
Provides an interface to Parse's logging and analytics backend.
Methods will return immediately and cache requests (along with timestamps)
to be handled in the background.
Tracks this application being launched.
An Async Task that can be waited on or ignored.
Tracks the occurrence of a custom event with additional dimensions.
Parse will store a data point at the time of invocation with the
given event name.
Dimensions will allow segmentation of the occurrences of this
custom event.
To track a user signup along with additional metadata, consider the
following:
IDictionary<string, string> dims = new Dictionary<string, string> {
{ "gender", "m" },
{ "source", "web" },
{ "dayType", "weekend" }
};
ParseAnalytics.TrackEventAsync("signup", dims);
There is a default limit of 8 dimensions per event tracked.
The name of the custom event to report to ParseClient
as having happened.
An Async Task that can be waited on or ignored.
Tracks the occurrence of a custom event with additional dimensions.
Parse will store a data point at the time of invocation with the
given event name.
Dimensions will allow segmentation of the occurrences of this
custom event.
To track a user signup along with additional metadata, consider the
following:
IDictionary<string, string> dims = new Dictionary<string, string> {
{ "gender", "m" },
{ "source", "web" },
{ "dayType", "weekend" }
};
ParseAnalytics.TrackEventAsync("signup", dims);
There is a default limit of 8 dimensions per event tracked.
The name of the custom event to report to ParseClient
as having happened.
The dictionary of information by which to
segment this event.
An Async Task that can be waited on or ignored.
Private method, used by platform-specific extensions to report an app-open
to the server.
An identifying hash for a given push notification,
passed down from the server.
An Async Task that can be waited on or ignored.
This method adds event listeners to track app opens from tiles, the app list,
and push notifications. Windows Phone 8 developers should use TrackAppOpens instead of
TrackAppOpenedAsync, which this method will call automatically.
This method can be called in Application_Launching or as follows in the Application constructor:
this.Startup += (sender, args) => {
ParseAnalytics.TrackAppOpens(RootFrame);
};
The RootFrame of the Application.
Provides a set of utilities for using Parse with Facebook.
Initializes Facebook for use with Parse.
Your Facebook application ID.
Logs in a using Facebook for authentication. If a user for the
given Facebook credentials does not already exist, a new user will be created.
The user's Facebook ID.
A valid access token for the user.
The expiration date of the access token.
The cancellation token.
The user that was either logged in or created.
Logs in a using Facebook for authentication. If a user for the
given Facebook credentials does not already exist, a new user will be created.
The user's Facebook ID.
A valid access token for the user.
The expiration date of the access token.
The user that was either logged in or created.
Links a to a Facebook account, allowing you to use Facebook
for authentication, and providing access to Facebook data for the user.
The user to link to a Facebook account.
The user's Facebook ID.
A valid access token for the user.
The expiration date of the access token.
The cancellation token.
Links a to a Facebook account, allowing you to use Facebook
for authentication, and providing access to Facebook data for the user.
The user to link to a Facebook account.
The user's Facebook ID.
A valid access token for the user.
The expiration date of the access token.
Gets whether the given user is linked to a Facebook account. This can only be used on
the currently authorized user.
The user to check.
true if the user is linked to a Facebook account.
Unlinks a user from a Facebook account. Unlinking a user will save the user's data.
The user to unlink.
The cancellation token.
Unlinks a user from a Facebook account. Unlinking a user will save the user's data.
The user to unlink.
Fetches the app's ProductID from its manifest.
Checks whether the Uri passed into your application comes from the Facebook
app as a result of a completed login attempt.
Your code will usually look like this:
RootFrame.Navigating += async (sender, e) => {
if (ParseFacebookUtils.IsLoginRedirect(e.Uri)) {
ParseUser user = await ParseFacebookUtils.EndLoginAsync(
sender, e, new Uri("/LandingPage.xaml", UriKind.Relative));
// A new user is now logged in.
}
};
true iff the Uri is a Facebook login redirect, false
otherwise
Call this method within your RootFrame.Navigating event handler to complete native Facebook
sign-on. When handling a Facebook login redirect URI, this method will cancel the
pending navigation, begin asynchronously logging in the user, and immediately navigate
to the .
Your code will usually look like this:
RootFrame.Navigating += async (sender, e) => {
if (ParseFacebookUtils.IsLoginRedirect(e.Uri)) {
ParseUser user = await ParseFacebookUtils.EndLoginAsync(
sender, e, new Uri("/LandingPage.xaml", UriKind.Relative));
// A new user is now logged in.
}
};
The sender for the Navigating event.
The Navigating event args.
The Uri within your app to redirect to.
The ParseUser created or logged in using Facebook credentials, or null if
this was not a Facebook login redirect.
Logs in a using Facebook for authentication. If a user for the
given Facebook credentials does not already exist, a new user will be created.
The user will be logged in through the Facebook app's single sign-on mechanism.
You must add a handler to your RootFrame's Navigating event that calls EndLogInAsync so
that ParseFacebookUtils can handle incoming navigation attempts.
=
A list of Facebook permissions to request.
Logs in a using Facebook for authentication. If a user for the
given Facebook credentials does not already exist, a new user will be created.
The user will be logged in through Facebook's OAuth web flow, so you must supply a
that will be navigated to Facebook's authentication pages.
A web view that will be used to present the authorization pages
to the user.
A list of Facebook permissions to request.
The cancellation token.
The user that was either logged in or created.
Links a to a Facebook account, allowing you to use Facebook
for authentication, and providing access to Facebook datta for the user.
The user will be logged in through Facebook's OAuth web flow, so you must supply a
that will be navigated to Facebook's authentication pages.
The user to link with Facebook.
A web view that will be used to present the authorization pages
to the user.
A list of Facebook permissions to request.
The cancellation token.
Logs in a using Facebook for authentication . If a user for the
given Facebook credentials does not already exist, a new user will be created.
The user will be logged in through Facebook's OAuth web flow, so you must supply a
that will be navigated to Facebook's authentication pages.
A web view that will be used to present the authorization pages
to the user.
A list of Facebook permissions to request.
The user that was either logged in or created.
Links a to a Facebook account, allowing you to use Facebook
for authentication, and providing access to Facebook datta for the user.
The user will be logged in through Facebook's OAuth web flow, so you must supply a
that will be navigated to Facebook's authentication pages.
The user to link with Facebook.
A web view that will be used to present the authorization pages
to the user.
A list of Facebook permissions to request.
Gets the Facebook Application ID as supplied to
Gets the access token for the currently logged in Facebook user. This can be used with a
Facebook SDK to get access to Facebook user data.
Gets an attribute from the Windows Phone App Manifest App element
the attribute name
the attribute value
This is a duplicate of what we have in ParseInstallation. We do it because
it's easier to maintain this way (rather than referencing PlatformHooks everywhere).
Provides a dictionary that gets persisted on the filesystem between runs of the app.
This is analogous to NSUserDefaults in iOS.
Wraps the custom settings object for Parse so that it can be exposed as ApplicationSettings.
A utility class for sending and receiving push notifications.
Extract the JSON dictionary used to send this push.
The args parameter passed to a push received event.
The JSON dictionary used to send this push.
A method for getting the JSON dictionary used to send a push notification from the
OnNavigated event handler, i.e.
public override void OnNavigatedTo(NavigationEventArgs args) {
var json = PushJson(args);
/* ... */
}
The args parameter passed to OnNavigatedTo
The JSON dictionary used to send this push.
Creates a push which will target every device. The Data field must be set before calling SendAsync.
Request a push to be sent. When this task completes, Parse has successfully acknowledged a request
to send push notifications but has not necessarily finished sending all notifications
requested. The current status of recent push notifications can be seen in your Push Notifications
console on http://parse.com
A Task for continuation.
Request a push to be sent. When this task completes, Parse has successfully acknowledged a request
to send push notifications but has not necessarily finished sending all notifications
requested. The current status of recent push notifications can be seen in your Push Notifications
console on http://parse.com
CancellationToken to cancel the current operation.
Pushes a simple message to every device. This is shorthand for:
var push = new ParsePush();
push.Data = new Dictionary<string, object>{{"alert", alert}};
return push.SendAsync();
The alert message to send.
Pushes a simple message to every device subscribed to channel. This is shorthand for:
var push = new ParsePush();
push.Channels = new List<string> { channel };
push.Data = new Dictionary<string, object>{{"alert", alert}};
return push.SendAsync();
The alert message to send.
An Installation must be subscribed to channel to receive this Push Notification.
Pushes a simple message to every device subscribed to any of channels. This is shorthand for:
var push = new ParsePush();
push.Channels = channels;
push.Data = new Dictionary<string, object>{{"alert", alert}};
return push.SendAsync();
The alert message to send.
An Installation must be subscribed to any of channels to receive this Push Notification.
Pushes a simple message to every device matching the target query. This is shorthand for:
var push = new ParsePush();
push.Query = query;
push.Data = new Dictionary<string, object>{{"alert", alert}};
return push.SendAsync();
The alert message to send.
A query filtering the devices which should receive this Push Notification.
Pushes an arbitrary payload to every device. This is shorthand for:
var push = new ParsePush();
push.Data = data;
return push.SendAsync();
A push payload. See the ParsePush.Data property for more information.
Pushes an arbitrary payload to every device subscribed to channel. This is shorthand for:
var push = new ParsePush();
push.Channels = new List<string> { channel };
push.Data = data;
return push.SendAsync();
A push payload. See the ParsePush.Data property for more information.
An Installation must be subscribed to channel to receive this Push Notification.
Pushes an arbitrary payload to every device subscribed to any of channels. This is shorthand for:
var push = new ParsePush();
push.Channels = channels;
push.Data = data;
return push.SendAsync();
A push payload. See the ParsePush.Data property for more information.
An Installation must be subscribed to any of channels to receive this Push Notification.
Pushes an arbitrary payload to every device matching target. This is shorthand for:
var push = new ParsePush();
push.Query = query
push.Data = data;
return push.SendAsync();
A push payload. See the ParsePush.Data property for more information.
A query filtering the devices which should receive this Push Notification.
Subscribe the current installation to this channel. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.AddUniqueToList("channels", channel);
installation.SaveAsync();
The channel to which this installation should subscribe.
Subscribe the current installation to this channel. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.AddUniqueToList("channels", channel);
installation.SaveAsync(cancellationToken);
The channel to which this installation should subscribe.
CancellationToken to cancel the current operation.
Subscribe the current installation to these channels. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.AddRangeUniqueToList("channels", channels);
installation.SaveAsync();
The channels to which this installation should subscribe.
Subscribe the current installation to these channels. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.AddRangeUniqueToList("channels", channels);
installation.SaveAsync(cancellationToken);
The channels to which this installation should subscribe.
CancellationToken to cancel the current operation.
Unsubscribe the current installation from this channel. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.Remove("channels", channel);
installation.SaveAsync();
The channel from which this installation should unsubscribe.
Unsubscribe the current installation from this channel. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.Remove("channels", channel);
installation.SaveAsync(cancellationToken);
The channel from which this installation should unsubscribe.
CancellationToken to cancel the current operation.
Unsubscribe the current installation from these channels. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.RemoveAllFromList("channels", channels);
installation.SaveAsync();
The channels from which this installation should unsubscribe.
Unsubscribe the current installation from these channels. This is shorthand for:
var installation = ParseInstallation.CurrentInstallation;
installation.RemoveAllFromList("channels", channels);
installation.SaveAsync(cancellationToken);
The channels from which this installation should unsubscribe.
CancellationToken to cancel the current operation.
An event fired when a push notification of any type (i.e. toast, tile, badge, or raw) is
received.
A generic event handler for notifications of all types. Because this event is also fired
when a raw notification is sent, the event args are very hard to use. You only get a byte
stream! We'll reveal this publicly once we support raw notifications; in the meantime we
should leave ToastNotificationReceived as the golden road.
An installation query that specifies which installations shoudl receive
this push.
This should not be used in tandem with Channels.
A short-hand to set a query which only discriminates on the channels to which a device is subscribed.
This is shorthand for:
var push = new Push();
push.Query = ParseInstallation.Query.WhereKeyContainedIn("channels", channels);
This cannot be used in tandem with Query.
The time at which this push will expire. This should not be used in tandem with ExpirationInterval.
The time from initial schedul when this push will expire. This should not be used in tandem with Expiration.
The contents of this push. Some keys have special meaning. A full list of pre-defined
keys can be found in the Parse Push Guide. The following keys affect WinRT devices.
Keys which do not start with x-winrt- can be prefixed with x-winrt- to specify an
override only sent to winrt devices.
alert: the body of the alert text.
title: The title of the text.
x-winrt-payload: A full XML payload to be sent to WinRT installations instead of
the auto-layout.
This should not be used in tandem with Alert.
A conveninence method which sets Data to a dictionary with alert as its only field. Equivalent to
Data = new Dictionary<string, object> {{"alert", alert}};
This should not be used in tandem with Data.
An event fired when a push notification is received.
Represents this app installed on this device. Use this class to track infomation you want
to sample from (i.e. if you update a field on app launch, you can issue a query to see
the number of devices which were active in the last N hours).
Whether the currentInstallation is known to match the serialized version on disk.
This is useful for saving a filesystem check if you try to load currentInstallation
frequently while there is none on disk.
Constructs a new ParseInstallation. Generally, you should not need to construct
ParseInstallations yourself. Instead use .
This mapping of Windows names to a standard everyone else uses is maintained
by the Unicode consortium, which makes this officially the first helpful
interaction between Unicode and Microsoft.
Unfortunately this is a little lossy in that we only store the first mapping in each zone because
Microsoft does not give us more granular location information.
Built from http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/zone_tzid.html
The runtime target of this application. Always returns winphone
Gets the application name from WMAppManifest.xml.
Application name.
Gets the application unique identifier from WMAppManifest.xml.
Application identifier.
Gets the application version from WMAppManifest.xml.
Application version.
Gets current Timezone of the device.
Current Timezone of the device.
Future proofing: Right now there's only one valid channel for the app, but we will likely
want to allow additional channels for auxiliary tiles (i.e. a contacts app can have a new
channel for each contact and the UI needs to pop up on the right tile). The expansion job
generically has one _Installation field it passes to device-specific code, so we store a map
of tag -> channel URI. Right now, there is only one valid tag and it is automatic.
Unsed variable warnings are suppressed becaue this const is used in WinRT and WinPhone but not NetFx.
Gets an attribute from the Windows Phone App Manifest App element
the attribute name
the attribute value
Gets the ParseInstallation representing this app on this device.
Constructs a for ParseInstallations.
Only the following types of queries are allowed for installations:
query.GetAsync(objectId)
query.WhereEqualTo(key, value)
query.WhereMatchesKeyInQuery<TOther>(key, keyInQuery, otherQuery)
You can add additional query conditions, but one of the above must appear as a top-level AND
clause in the query.
A GUID that uniquely names this app installed on this device.
The runtime target of this installation object.
The user-friendly display name of this application.
A version string consisting of Major.Minor.Build.Revision.
The system-dependent unique identifier of this installation. This identifier should be
sufficient to distinctly name an app on stores which may allow multiple apps with the
same display name.
The time zone in which this device resides. This string is in the tz database format
Parse uses for local-time pushes. Due to platform restrictions, the mapping is less
granular on Windows than it may be on other systems. E.g. The zones
America/Vancouver America/Dawson America/Whitehorse, America/Tijuana, PST8PDT, and
America/Los_Angeles are all reported as America/Los_Angeles.
The version of the Parse SDK used to build this application.
A sequence of arbitrary strings which are used to identify this installation for push notifications.
By convention, the empty string is known as the "Broadcast" channel.