motion-firebase 1.0.5

data/lib/vendor/FacebookSDK.framework/Versions/A/Headers/FBSessionTokenCachingStrategy.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2012 Facebook
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import "FBAccessTokenData.h"
+
+/*! 
+ @class
+ 
+ @abstract
+ The `FBSessionTokenCachingStrategy` class is responsible for persisting and retrieving cached data related to
+ an <FBSession> object, including the user's Facebook access token. 
+ 
+ @discussion
+ `FBSessionTokenCachingStrategy` is designed to be instantiated directly or used as a base class. Usually default
+ token caching behavior is sufficient, and you do not need to interface directly with `FBSessionTokenCachingStrategy` objects.
+ However, if you need to control where or how `FBSession` information is cached, then you may take one of two approaches.
+ 
+ The first and simplest approach is to instantiate an instance of `FBSessionTokenCachingStrategy`, and then pass
+ the instance to `FBSession` class' `init` method. This enables your application to control the key name used in
+ `NSUserDefaults` to store session information. You may consider this approach if you plan to cache session information
+ for multiple users.
+ 
+ The second and more advanced approached is to derive a custom class from `FBSessionTokenCachingStrategy`, which will
+ be responsible for caching behavior of your application. This approach is useful if you need to change where the 
+ information is cached, for example if you prefer to use the filesystem or make a network connection to fetch and
+ persist cached tokens.  Inheritors should override the cacheTokenInformation, fetchTokenInformation, and clearToken methods.
+ Doing this enables your application to implement any token caching scheme, including no caching at all (see
+ `[FBSessionTokenCachingStrategy* nullCacheInstance ]`.
+ 
+ Direct use of `FBSessionTokenCachingStrategy`is an advanced technique. Most applications use <FBSession> objects without
+ passing an `FBSessionTokenCachingStrategy`, which yields default caching to `NSUserDefaults`.
+ */
+@interface FBSessionTokenCachingStrategy : NSObject
+
+/*!
+ @abstract Initializes and returns an instance
+ */
+- (id)init;
+
+/*!
+ @abstract 
+ Initializes and returns an instance
+ 
+ @param tokenInformationKeyName     Specifies a key name to use for cached token information in NSUserDefaults, nil
+ indicates a default value of @"FBAccessTokenInformationKey"
+ */
+- (id)initWithUserDefaultTokenInformationKeyName:(NSString*)tokenInformationKeyName;
+
+/*!
+ @abstract 
+ Called by <FBSession> (and overridden by inheritors), in order to cache token information.
+ 
+ @param tokenInformation            Dictionary containing token information to be cached by the method
+ @discussion You should favor overriding this instead of `cacheFBAccessTokenData` only if you intend
+ to cache additional data not captured by the FBAccessTokenData type.
+ */
+- (void)cacheTokenInformation:(NSDictionary*)tokenInformation;
+
+/*!
+ @abstract Cache the supplied token.
+ @param accessToken The token instance.
+ @discussion This essentially wraps a call to `cacheTokenInformation` so you should
+ override this when providing a custom token caching strategy.
+*/
+- (void)cacheFBAccessTokenData:(FBAccessTokenData *)accessToken;
+
+/*!
+ @abstract 
+ Called by <FBSession> (and overridden by inheritors), in order to fetch cached token information
+ 
+ @discussion
+ An overriding implementation should only return a token if it
+ can also return an expiration date, otherwise return nil.
+ You should favor overriding this instead of `fetchFBAccessTokenData` only if you intend
+ to cache additional data not captured by the FBAccessTokenData type.
+
+ */
+- (NSDictionary*)fetchTokenInformation;
+
+/*!
+ @abstract
+ Fetches the cached token instance.
+ 
+ @discussion
+ This essentially wraps a call to `fetchTokenInformation` so you should
+ override this when providing a custom token caching strategy.
+ */
+- (FBAccessTokenData *)fetchFBAccessTokenData;
+
+/*!
+ @abstract 
+ Called by <FBSession> (and overridden by inheritors), in order delete any cached information for the current token
+ */
+- (void)clearToken;
+
+/*!
+ @abstract 
+ Helper function called by the SDK as well as apps, in order to fetch the default strategy instance.
+ */
++ (FBSessionTokenCachingStrategy*)defaultInstance;
+
+/*!
+ @abstract
+ Helper function to return a FBSessionTokenCachingStrategy instance that does not perform any caching.
+ */
++ (FBSessionTokenCachingStrategy*)nullCacheInstance;
+
+/*!
+ @abstract 
+ Helper function called by the SDK as well as application code, used to determine whether a given dictionary
+ contains the minimum token information usable by the <FBSession>.
+ 
+ @param tokenInformation            Dictionary containing token information to be validated
+ */
++ (BOOL)isValidTokenInformation:(NSDictionary*)tokenInformation;
+
+@end
+
+// The key to use with token information dictionaries to get and set the token value
+extern NSString *const FBTokenInformationTokenKey;
+
+// The to use with token information dictionaries to get and set the expiration date
+extern NSString *const FBTokenInformationExpirationDateKey;
+
+// The to use with token information dictionaries to get and set the refresh date
+extern NSString *const FBTokenInformationRefreshDateKey;
+
+// The key to use with token information dictionaries to get the related user's fbid
+extern NSString *const FBTokenInformationUserFBIDKey;
+
+// The key to use with token information dictionaries to determine whether the token was fetched via Facebook Login
+extern NSString *const FBTokenInformationIsFacebookLoginKey;
+
+// The key to use with token information dictionaries to determine whether the token was fetched via the OS
+extern NSString *const FBTokenInformationLoginTypeLoginKey;
+
+// The key to use with token information dictionaries to get the latest known permissions
+extern NSString *const FBTokenInformationPermissionsKey;

data/lib/vendor/FacebookSDK.framework/Versions/A/Headers/FBSettings.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2012 Facebook
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*
+ * Constants defining logging behavior.  Use with <[FBSettings setLoggingBehavior]>.
+ */
+
+/*! Log requests from FBRequest* classes */
+extern NSString *const FBLoggingBehaviorFBRequests;
+
+/*! Log requests from FBURLConnection* classes */
+extern NSString *const FBLoggingBehaviorFBURLConnections;
+
+/*! Include access token in logging. */
+extern NSString *const FBLoggingBehaviorAccessTokens;
+
+/*! Log session state transitions. */
+extern NSString *const FBLoggingBehaviorSessionStateTransitions;
+
+/*! Log performance characteristics */
+extern NSString *const FBLoggingBehaviorPerformanceCharacteristics;
+
+/*! Log Insights interactions */
+extern NSString *const FBLoggingBehaviorInsights;
+
+/*! Log errors likely to be preventable by the developer. This is in the default set of enabled logging behaviors. */
+extern NSString *const FBLoggingBehaviorDeveloperErrors;
+
+@class FBGraphObject;
+
+/*! 
+ @typedef
+ 
+ @abstract Block type used to get install data that is returned by server when publishInstall is called
+ @discussion
+ */
+typedef void (^FBInstallResponseDataHandler)(FBGraphObject *response, NSError *error);
+
+@interface FBSettings : NSObject
+
+/*!
+ @method
+ 
+ @abstract Retrieve the current Facebook SDK logging behavior.
+ 
+ */
++ (NSSet *)loggingBehavior;
+
+/*!
+ @method
+
+ @abstract Set the current Facebook SDK logging behavior.  This should consist of strings defined as
+ constants with FBLogBehavior*, and can be constructed with, e.g., [NSSet initWithObjects:].
+
+ @param loggingBehavior A set of strings indicating what information should be logged.  If nil is provided, the logging
+ behavior is reset to the default set of enabled behaviors.  Set in an empty set in order to disable all logging.
+ */
++ (void)setLoggingBehavior:(NSSet *)loggingBehavior;
+
+/*! @abstract Retreive the current auto publish behavior.  Defaults to YES. */
++ (BOOL)shouldAutoPublishInstall;
+
+/*!
+ @method
+
+ @abstract Sets whether the SDK will automatically publish an install to Facebook during first FBSession init
+ or on first network request to Facebook.
+
+ @param autoPublishInstall      If YES, automatically publish the install; if NO, do not.
+ */
++ (void)setShouldAutoPublishInstall:(BOOL)autoPublishInstall;
+
+// For best results, call this function during app activation.
+/*!
+ @method
+
+ @abstract Manually publish an attributed install to the facebook graph. Calling this method will implicitly 
+ turn off auto-publish.  This method acquires the current attribution id from the facebook application, queries the
+ graph API to determine if the application has install attribution enabled, publishes the id, and records 
+ success to avoid reporting more than once.
+
+ @param appID A specific appID to publish an install for.  If nil, uses [FBSession defaultAppID].
+ */
++ (void)publishInstall:(NSString *)appID;
+
+/*!
+ @method
+
+ @abstract Manually publish an attributed install to the Facebook graph, and return the server response back in
+ the supplied handler.  Calling this method will implicitly turn off auto-publish.  This method acquires the 
+ current attribution id from the facebook application, queries the graph API to determine if the application 
+ has install attribution enabled, publishes the id, and records success to avoid reporting more than once.
+
+ @param appID   A specific appID to publish an install for.  If nil, uses [FBSession defaultAppID].
+ @param handler A block to call with the server's response.
+ */
++ (void)publishInstall:(NSString *)appID
+           withHandler:(FBInstallResponseDataHandler)handler;
+
+/*!
+ @method
+ 
+ @abstract Retrieve the Client Token that has been set via [FBSettings setClientToken]
+ */
++ (NSString *)clientToken;
+
+/*!
+ @method
+ 
+ @abstract Sets the Client Token for the Facebook App.  This is needed for certain API calls when made anonymously,
+ without a user-based Session. Calls to FBInsights logging events are examples of this, when there may 
+ have been no user login established.
+ 
+ @param clientToken  The Facebook App's "client token", which, for a given appid can be found in the Security 
+ section of the Advanced tab of the Facebook App settings found at <https://developers.facebook.com/apps/[your-app-id]>
+ 
+ */
++ (void)setClientToken:(NSString *)clientToken;
+
+
+@end

data/lib/vendor/FacebookSDK.framework/Versions/A/Headers/FBTestSession.h

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 Facebook
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#import "FBSession.h"
+
+#if defined (DEBUG)
+    #define SAFE_TO_USE_FBTESTSESSION
+#endif
+
+#if !defined(SAFE_TO_USE_FBTESTSESSION)
+    #pragma message ("warning: using FBTestSession, which is designed for unit-testing uses only, in non-DEBUG code -- ensure this is what you really want")
+#endif
+
+/*! 
+ Consider using this tag to pass to sessionWithSharedUserWithPermissions:uniqueUserTag: when
+ you need a second unique test user in a test case. Using the same tag each time reduces
+ the proliferation of test users.
+ */
+extern NSString *kSecondTestUserTag;
+/*! 
+ Consider using this tag to pass to sessionWithSharedUserWithPermissions:uniqueUserTag: when
+ you need a third unique test user in a test case. Using the same tag each time reduces
+ the proliferation of test users.
+ */
+extern NSString *kThirdTestUserTag;
+
+/*!
+ @class FBTestSession
+ 
+ @abstract
+ Implements an FBSession subclass that knows about test users for a particular
+ application. This should never be used from a real application, but may be useful
+ for writing unit tests, etc.
+ 
+ @discussion
+ Facebook allows developers to create test accounts for testing their applications'
+ Facebook integration (see https://developers.facebook.com/docs/test_users/). This class
+ simplifies use of these accounts for writing unit tests. It is not designed for use in
+ production application code.
+ 
+ The main use case for this class is using sessionForUnitTestingWithPermissions:mode:
+ to create a session for a test user. Two modes are supported. In "shared" mode, an attempt
+ is made to find an existing test user that has the required permissions and, if it is not
+ currently in use by another FBTestSession, just use that user. If no such user is available,
+ a new one is created with the required permissions. In "private" mode, designed for
+ scenarios which require a new user in a known clean state, a new test user will always be
+ created, and it will be automatically deleted when the FBTestSession is closed.
+ 
+ Note that the shared test user functionality depends on a naming convention for the test users.
+ It is important that any testing of functionality which will mutate the permissions for a
+ test user NOT use a shared test user, or this scheme will break down. If a shared test user
+ seems to be in an invalid state, it can be deleted manually via the Web interface at
+ https://developers.facebook.com/apps/APP_ID/permissions?role=test+users.
+ */
+@interface FBTestSession : FBSession
+
+/// The app access token (composed of app ID and secret) to use for accessing test users.
+@property (readonly, copy) NSString *appAccessToken;
+/// The ID of the test user associated with this session.
+@property (readonly, copy) NSString *testUserID;
+/// The App ID of the test app as configured in the plist.
+@property (readonly, copy) NSString *testAppID;
+/// The App Secret of the test app as configured in the plist.
+@property (readonly, copy) NSString *testAppSecret;
+
+/*!
+ @abstract
+ Constructor helper to create a session for use in unit tests
+ 
+ @discussion
+ This method creates a session object which uses a shared test user with the right permissions,
+ creating one if necessary on open (but not deleting it on close, so it can be re-used in later
+ tests). Calling this method multiple times may return sessions with the same user. If this is not
+ desired, use the variant sessionWithSharedUserWithPermissions:uniqueUserTag:.
+ 
+ This method should not be used in application code -- but is useful for creating unit tests
+ that use the Facebook SDK.
+ 
+ @param permissions     array of strings naming permissions to authorize; nil indicates 
+ a common default set of permissions should be used for unit testing
+  */
++ (id)sessionWithSharedUserWithPermissions:(NSArray*)permissions;
+
+/*!
+ @abstract
+ Constructor helper to create a session for use in unit tests
+ 
+ @discussion
+ This method creates a session object which uses a shared test user with the right permissions,
+ creating one if necessary on open (but not deleting it on close, so it can be re-used in later
+ tests). 
+ 
+ This method should not be used in application code -- but is useful for creating unit tests
+ that use the Facebook SDK.
+ 
+ @param permissions     array of strings naming permissions to authorize; nil indicates 
+ a common default set of permissions should be used for unit testing
+ 
+ @param uniqueUserTag   a string which will be used to make this user unique among other
+ users with the same permissions. Useful for tests which require two or more users to interact
+ with each other, and which therefore must have sessions associated with different users. For
+ this case, consider using kSecondTestUserTag and kThirdTestUserTag so these users can be shared
+ with other, similar, tests.
+ */
++ (id)sessionWithSharedUserWithPermissions:(NSArray*)permissions 
+                             uniqueUserTag:(NSString*)uniqueUserTag;
+
+/*!
+ @abstract
+ Constructor helper to create a session for use in unit tests
+ 
+ @discussion
+ This method creates a session object which creates a test user on open, and destroys the user on
+ close; This method should not be used in application code -- but is useful for creating unit tests
+ that use the Facebook SDK.
+ 
+ @param permissions     array of strings naming permissions to authorize; nil indicates 
+ a common default set of permissions should be used for unit testing
+ */
++ (id)sessionWithPrivateUserWithPermissions:(NSArray*)permissions;
+
+@end

data/lib/vendor/FacebookSDK.framework/Versions/A/Headers/FBUserSettingsViewController.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2010 Facebook
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <UIKit/UIKit.h>
+#import "FBSession.h"
+#import "FBViewController.h"
+
+/*!
+ @protocol 
+ 
+ @abstract
+ The `FBUserSettingsDelegate` protocol defines the methods called by a <FBUserSettingsViewController>.
+ */
+@protocol FBUserSettingsDelegate <FBViewControllerDelegate>
+
+@optional
+
+/*!
+ @abstract
+ Called when the view controller will log the user out in response to a button press.
+
+ @param sender          The view controller sending the message.
+ */
+- (void)loginViewControllerWillLogUserOut:(id)sender;
+
+/*!
+ @abstract
+ Called after the view controller logged the user out in response to a button press.
+
+ @param sender          The view controller sending the message.
+ */
+- (void)loginViewControllerDidLogUserOut:(id)sender;
+
+/*!
+ @abstract
+ Called when the view controller will log the user in in response to a button press.
+ Note that logging in can fail for a number of reasons, so there is no guarantee that this
+ will be followed by a call to loginViewControllerDidLogUserIn:. Callers wanting more granular
+ notification of the session state changes can use KVO or the NSNotificationCenter to observe them.
+
+ @param sender          The view controller sending the message.
+ */
+- (void)loginViewControllerWillAttemptToLogUserIn:(id)sender;
+
+/*!
+ @abstract
+ Called after the view controller successfully logged the user in in response to a button press.
+
+ @param sender          The view controller sending the message.
+ */
+- (void)loginViewControllerDidLogUserIn:(id)sender;
+
+/*!
+ @abstract
+ Called if the view controller encounters an error while trying to log a user in.
+
+ @param sender          The view controller sending the message.
+ @param error           The error encountered.
+ @discussion See https://developers.facebook.com/docs/technical-guides/iossdk/errors/
+ for error handling best practices.
+ */
+- (void)loginViewController:(id)sender receivedError:(NSError *)error;
+
+@end
+
+
+/*!
+ @class FBUserSettingsViewController
+ 
+ @abstract
+ The `FBUserSettingsViewController` class provides a user interface exposing a user's
+ Facebook-related settings. Currently, this is limited to whether they are logged in or out
+ of Facebook.
+
+ Because of the size of some graphics used in this view, its resources are packaged as a separate
+ bundle. In order to use `FBUserSettingsViewController`, drag the `FBUserSettingsViewResources.bundle`
+ from the SDK directory into your Xcode project.
+ */
+@interface FBUserSettingsViewController : FBViewController
+
+/*!
+ @abstract
+ The permissions to request if the user logs in via this view.
+ */
+@property (nonatomic, copy) NSArray *permissions __attribute__((deprecated));
+
+/*!
+ @abstract
+ The read permissions to request if the user logs in via this view.
+ 
+ @discussion
+ Note, that if read permissions are specified, then publish permissions should not be specified. 
+ */
+@property (nonatomic, copy) NSArray *readPermissions;
+
+/*!
+ @abstract
+ The publish permissions to request if the user logs in via this view.
+ 
+ @discussion
+ Note, that a defaultAudience value of FBSessionDefaultAudienceOnlyMe, FBSessionDefaultAudienceEveryone, or
+ FBSessionDefaultAudienceFriends should be set if publish permissions are specified. Additionally, when publish
+ permissions are specified, then read should not be specified.
+ */
+@property (nonatomic, copy) NSArray *publishPermissions;
+
+/*!
+ @abstract
+ The default audience to use, if publish permissions are requested at login time.
+ */
+@property (nonatomic, assign) FBSessionDefaultAudience defaultAudience;
+
+@end
+

data/lib/vendor/FacebookSDK.framework/Versions/A/Headers/FBViewController.h

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2010 Facebook
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <UIKit/UIKit.h>
+
+@class FBViewController;
+
+/*!
+ @typedef FBModalCompletionHandler
+ 
+ @abstract
+ A block that is passed to [FBViewController presentModallyInViewController:animated:handler:]
+ and called when the view controller is dismissed via either Done or Cancel.
+ 
+ @param sender          The <FBViewController> that is being dismissed.
+ 
+ @param donePressed     If YES, Done was pressed. If NO, Cancel was pressed.
+ */
+typedef void (^FBModalCompletionHandler)(FBViewController *sender, BOOL donePressed);
+
+/*!
+ @protocol 
+ 
+ @abstract
+ The `FBViewControllerDelegate` protocol defines the methods called when the Cancel or Done
+ buttons are pressed in a <FBViewController>.
+ */
+@protocol FBViewControllerDelegate <NSObject>
+
+@optional
+
+/*!
+ @abstract
+ Called when the Cancel button is pressed on a modally-presented <FBViewController>.
+ 
+ @param sender          The view controller sending the message.
+ */
+- (void)facebookViewControllerCancelWasPressed:(id)sender;
+
+/*!
+ @abstract
+ Called when the Done button is pressed on a modally-presented <FBViewController>.
+
+ @param sender          The view controller sending the message.
+ */
+- (void)facebookViewControllerDoneWasPressed:(id)sender;
+
+@end
+
+
+/*!
+ @class FBViewController
+ 
+ @abstract
+ The `FBViewController` class is a base class encapsulating functionality common to several
+ other view controller classes. Specifically, it provides UI when a view controller is presented
+ modally, in the form of optional Cancel and Done buttons.
+ */
+@interface FBViewController : UIViewController
+
+/*!
+ @abstract
+ The Cancel button to display when presented modally. If nil, no Cancel button is displayed.
+ If this button is provided, its target and action will be redirected to internal handlers, replacing
+ any previous target that may have been set.
+ */
+@property (nonatomic, retain) IBOutlet UIBarButtonItem *cancelButton;
+
+/*!
+ @abstract
+ The Done button to display when presented modally. If nil, no Done button is displayed.
+ If this button is provided, its target and action will be redirected to internal handlers, replacing
+ any previous target that may have been set.
+ */
+@property (nonatomic, retain) IBOutlet UIBarButtonItem *doneButton;
+
+/*!
+ @abstract
+ The delegate that will be called when Cancel or Done is pressed. Derived classes may specify
+ derived types for their delegates that provide additional functionality.
+ */
+@property (nonatomic, assign) IBOutlet id<FBViewControllerDelegate> delegate;
+
+/*!
+ @abstract
+ The view into which derived classes should put their subviews. This view will be resized correctly
+ depending on whether or not a toolbar is displayed.
+ */
+@property (nonatomic, readonly, retain) UIView *canvasView;
+
+/*!
+ @abstract
+ Provides a wrapper that presents the view controller modally and automatically dismisses it
+ when either the Done or Cancel button is pressed. 
+ 
+ @param viewController  The view controller that is presenting this view controller.
+ @param animated        If YES, presenting and dismissing the view controller is animated.
+ @param handler         The block called when the Done or Cancel button is pressed.
+ */
+- (void)presentModallyFromViewController:(UIViewController*)viewController
+                                animated:(BOOL)animated
+                                 handler:(FBModalCompletionHandler)handler;
+
+@end
+