944 lines
36 KiB
Plaintext
944 lines
36 KiB
Plaintext
// Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
|
|
//
|
|
// You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
|
|
// copy, modify, and distribute this software in source code or binary form for use
|
|
// in connection with the web services and APIs provided by Facebook.
|
|
//
|
|
// As with any software that integrates with the Facebook platform, your use of
|
|
// this software is subject to the Facebook Developer Principles and Policies
|
|
// [http://developers.facebook.com/policy/]. This copyright notice shall be
|
|
// included in all copies or substantial portions of the software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
#import <SafariServices/SafariServices.h>
|
|
#import <AuthenticationServices/AuthenticationServices.h>
|
|
#import <FBSDKCoreKit/FBSDKCoreKit-Swift.h>
|
|
#import <FBSDKLoginKit/FBSDKLoginKit-Swift.h>
|
|
#import <Foundation/NSJSONSerialization.h>
|
|
|
|
#include "FBUnityInterface.h"
|
|
#include "FBUnitySDKDelegate.h"
|
|
#include "FBUnityUtility.h"
|
|
#include "FBSDK+Internal.h"
|
|
|
|
@interface FBUnityInterface()
|
|
|
|
@property (nonatomic, copy) NSString *openURLString;
|
|
|
|
@end
|
|
|
|
@implementation FBUnityInterface
|
|
|
|
#pragma mark Object Initialization
|
|
|
|
+ (FBUnityInterface *)sharedInstance
|
|
{
|
|
static dispatch_once_t pred;
|
|
static FBUnityInterface *shared = nil;
|
|
|
|
dispatch_once(&pred, ^{
|
|
shared = [[FBUnityInterface alloc] init];
|
|
shared.shareDialogMode = ShareDialogMode::AUTOMATIC;
|
|
});
|
|
|
|
return shared;
|
|
}
|
|
|
|
+ (void)load
|
|
{
|
|
UnityRegisterAppDelegateListener([FBUnityInterface sharedInstance]);
|
|
}
|
|
|
|
#pragma mark - App (Delegate) Lifecycle
|
|
|
|
// didBecomeActive: and onOpenURL: are called by Unity's AppController
|
|
// because we implement <AppDelegateListener> and registered via UnityRegisterAppDelegateListener(...) above.
|
|
|
|
- (void)didFinishLaunching:(NSNotification *)notification
|
|
{
|
|
[[FBSDKApplicationDelegate sharedInstance] application:[UIApplication sharedApplication]
|
|
didFinishLaunchingWithOptions:notification.userInfo];
|
|
}
|
|
|
|
- (void)didBecomeActive:(NSNotification *)notification
|
|
{
|
|
|
|
}
|
|
|
|
- (void)onOpenURL:(NSNotification *)notification
|
|
{
|
|
NSURL *url = notification.userInfo[@"url"];
|
|
BOOL isHandledByFBSDK = [[FBSDKApplicationDelegate sharedInstance] application:[UIApplication sharedApplication]
|
|
openURL:url
|
|
sourceApplication:notification.userInfo[@"sourceApplication"]
|
|
annotation:notification.userInfo[@"annotation"]];
|
|
if (!isHandledByFBSDK) {
|
|
[FBUnityInterface sharedInstance].openURLString = [url absoluteString];
|
|
}
|
|
}
|
|
|
|
#pragma mark - Implementation
|
|
|
|
- (void)configureAppId:(const char *)appId
|
|
frictionlessRequests:(bool)frictionlessRequests
|
|
urlSuffix:(const char *)urlSuffix
|
|
{
|
|
self.useFrictionlessRequests = frictionlessRequests;
|
|
|
|
if(appId) {
|
|
[FBSDKSettings.sharedSettings setAppID:[FBUnityUtility stringFromCString:appId]];
|
|
}
|
|
|
|
if(urlSuffix && strlen(urlSuffix) > 0) {
|
|
[FBSDKSettings.sharedSettings setAppURLSchemeSuffix:[FBUnityUtility stringFromCString:urlSuffix]];
|
|
}
|
|
|
|
NSDictionary *userData = [self getAccessTokenUserData] ?: @{};
|
|
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnInitComplete userData:userData requestId:0];
|
|
}
|
|
|
|
- (void)logInWithPublishPermissions:(int) requestId
|
|
scope:(const char *)scope
|
|
{
|
|
[self startLogin:requestId scope:scope isPublishPermLogin:YES];
|
|
}
|
|
|
|
- (void)logInWithReadPermissions:(int) requestId
|
|
scope:(const char *)scope
|
|
{
|
|
[self startLogin:requestId scope:scope isPublishPermLogin:NO];
|
|
}
|
|
|
|
- (void)startLogin:(int) requestId
|
|
scope:(const char *)scope
|
|
isPublishPermLogin:(BOOL)isPublishPermLogin
|
|
{
|
|
NSString *scopeStr = [FBUnityUtility stringFromCString:scope];
|
|
NSArray *permissions = nil;
|
|
if(scope && strlen(scope) > 0) {
|
|
permissions = [scopeStr componentsSeparatedByString:@","];
|
|
}
|
|
|
|
void (^loginHandler)(FBSDKLoginManagerLoginResult *,NSError *) = ^(FBSDKLoginManagerLoginResult *result, NSError *error) {
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnLoginComplete error:error requestId:requestId];
|
|
return;
|
|
} else if (result.isCancelled) {
|
|
[FBUnityUtility sendCancelToUnity:FBUnityMessageName_OnLoginComplete requestId:requestId];
|
|
return;
|
|
}
|
|
|
|
if ([self tryCompleteLoginWithRequestId:requestId]) {
|
|
return;
|
|
} else {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnLoginComplete errorMessage:@"Unknown login error" requestId:requestId];
|
|
}
|
|
};
|
|
|
|
FBSDKLoginManager *login = [[FBSDKLoginManager alloc] init];
|
|
[login logInWithPermissions:permissions
|
|
fromViewController:nil
|
|
handler:loginHandler];
|
|
}
|
|
|
|
- (void)loginWithTrackingPreference:(int)requestId
|
|
scope:(const char *)scope
|
|
tracking:(const char *)tracking
|
|
nonce:(const char *)nonce
|
|
{
|
|
NSString *scopeStr = [FBUnityUtility stringFromCString:scope];
|
|
NSArray *permissions = nil;
|
|
if(scope && strlen(scope) > 0) {
|
|
permissions = [scopeStr componentsSeparatedByString:@","];
|
|
}
|
|
|
|
NSString *trackingStr = [FBUnityUtility stringFromCString:tracking];
|
|
NSString *nonceStr = nil;
|
|
if (nonce) {
|
|
nonceStr = [FBUnityUtility stringFromCString:nonce];
|
|
}
|
|
FBSDKLoginConfiguration *config;
|
|
if (nonce) {
|
|
config = [[FBSDKLoginConfiguration alloc] initWithPermissions:permissions tracking:([trackingStr isEqualToString:@"enabled"] ? FBSDKLoginTrackingEnabled : FBSDKLoginTrackingLimited) nonce:nonceStr];
|
|
} else {
|
|
config = [[FBSDKLoginConfiguration alloc] initWithPermissions:permissions tracking:([trackingStr isEqualToString:@"enabled"] ? FBSDKLoginTrackingEnabled : FBSDKLoginTrackingLimited)];
|
|
}
|
|
|
|
void (^loginHandler)(FBSDKLoginManagerLoginResult *,NSError *) = ^(FBSDKLoginManagerLoginResult *result, NSError *error) {
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnLoginComplete error:error requestId:requestId];
|
|
return;
|
|
} else if (result.isCancelled) {
|
|
[FBUnityUtility sendCancelToUnity:FBUnityMessageName_OnLoginComplete requestId:requestId];
|
|
return;
|
|
}
|
|
|
|
if ([self tryCompleteLoginWithRequestId:requestId]) {
|
|
return;
|
|
} else {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnLoginComplete errorMessage:@"Unknown login error" requestId:requestId];
|
|
}
|
|
};
|
|
|
|
FBSDKLoginManager *login = [[FBSDKLoginManager alloc] init];
|
|
[login logInFromViewController:nil configuration:config completion:loginHandler];
|
|
}
|
|
|
|
- (void)logOut
|
|
{
|
|
FBSDKLoginManager *login = [[FBSDKLoginManager alloc] init];
|
|
[login logOut];
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnLogoutComplete userData:@{} requestId:0];
|
|
}
|
|
|
|
- (void)appRequestWithRequestId:(int)requestId
|
|
message:(const char *)message
|
|
actionType:(const char *)actionType
|
|
objectId:(const char *)objectId
|
|
to:(const char **)to
|
|
toLength:(int)toLength
|
|
filters:(const char *)filters
|
|
data:(const char *)data
|
|
title:(const char *)title
|
|
{
|
|
FBSDKGameRequestContent *content = [[FBSDKGameRequestContent alloc] init];
|
|
content.message = [FBUnityUtility stringFromCString:message];
|
|
content.actionType = [FBUnityUtility gameRequestActionTypeFromString:[FBUnityUtility stringFromCString:actionType]];
|
|
content.objectID = [FBUnityUtility stringFromCString:objectId];
|
|
if(to && toLength) {
|
|
NSMutableArray *toArray = [NSMutableArray array];
|
|
for(int i = 0; i < toLength; i++) {
|
|
[toArray addObject:[FBUnityUtility stringFromCString:to[i]]];
|
|
}
|
|
content.recipients = toArray;
|
|
}
|
|
content.filters = [FBUnityUtility gameRequestFilterFromString:[FBUnityUtility stringFromCString:filters]];
|
|
content.data = [FBUnityUtility stringFromCString:data];
|
|
content.title = [FBUnityUtility stringFromCString:title];
|
|
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestId];
|
|
NSError *error;
|
|
FBSDKGameRequestDialog *dialog = [[FBSDKGameRequestDialog alloc] initWithContent:content delegate:delegate];
|
|
dialog.isFrictionlessRequestsEnabled = self.useFrictionlessRequests;
|
|
|
|
if (![dialog validateWithError:&error]) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnAppRequestsComplete error:error requestId:requestId];
|
|
}
|
|
if (![dialog show]) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnAppRequestsComplete errorMessage:@"Failed to show request dialog" requestId:requestId];
|
|
}
|
|
}
|
|
|
|
- (void)shareLinkWithRequestId:(int)requestId
|
|
contentURL:(const char *)contentURL
|
|
contentTitle:(const char *)contentTitle
|
|
contentDescription:(const char *)contentDescription
|
|
photoURL:(const char *)photoURL
|
|
{
|
|
FBSDKShareLinkContent *linkContent = [[FBSDKShareLinkContent alloc] init];
|
|
|
|
NSString *contentUrlStr = [FBUnityUtility stringFromCString:contentURL];
|
|
if (contentUrlStr) {
|
|
linkContent.contentURL = [NSURL URLWithString:contentUrlStr];
|
|
}
|
|
|
|
[self shareContentWithRequestId:requestId
|
|
shareContent:linkContent
|
|
dialogMode:[self getDialogMode]];
|
|
}
|
|
|
|
- (void)shareFeedWithRequestId:(int)requestId
|
|
toId:(const char *)toID
|
|
link:(const char *)link
|
|
linkName:(const char *)linkName
|
|
linkCaption:(const char *)linkCaption
|
|
linkDescription:(const char *)linkDescription
|
|
picture:(const char *)picture
|
|
mediaSource:(const char *)mediaSource
|
|
{
|
|
FBSDKShareLinkContent *linkContent = [[FBSDKShareLinkContent alloc] init];
|
|
NSString *contentUrlStr = [FBUnityUtility stringFromCString:link];
|
|
if (contentUrlStr) {
|
|
linkContent.contentURL = [NSURL URLWithString:contentUrlStr];
|
|
}
|
|
|
|
NSMutableDictionary *feedParameters = [[NSMutableDictionary alloc] init];
|
|
NSString *toStr = [FBUnityUtility stringFromCString:toID];
|
|
if (toStr) {
|
|
[feedParameters setObject:toStr forKey:@"to"];
|
|
}
|
|
|
|
NSString *captionStr = [FBUnityUtility stringFromCString:linkCaption];
|
|
if (captionStr) {
|
|
[feedParameters setObject:captionStr forKey:@"caption"];
|
|
}
|
|
|
|
NSString *sourceStr = [FBUnityUtility stringFromCString:mediaSource];
|
|
if (sourceStr) {
|
|
[feedParameters setObject:sourceStr forKey:@"source"];
|
|
}
|
|
|
|
[linkContent addParameters:feedParameters bridgeOptions:FBSDKShareBridgeOptionsDefault];
|
|
[self shareContentWithRequestId:requestId
|
|
shareContent:linkContent
|
|
dialogMode:FBSDKShareDialogModeFeedWeb];
|
|
}
|
|
|
|
- (void)shareContentWithRequestId:(int)requestId
|
|
shareContent:(FBSDKShareLinkContent *)linkContent
|
|
dialogMode:(FBSDKShareDialogMode)dialogMode
|
|
{
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestId];
|
|
FBSDKShareDialog *dialog = [[FBSDKShareDialog alloc] initWithViewController:nil
|
|
content:linkContent
|
|
delegate:delegate];
|
|
dialog.mode = dialogMode;
|
|
|
|
NSError *error;
|
|
if (![dialog validateWithError:&error]) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnShareLinkComplete error:error requestId:requestId];
|
|
}
|
|
if (![dialog show]) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnShareLinkComplete errorMessage:@"Failed to show share dialog" requestId:requestId];
|
|
}
|
|
}
|
|
|
|
- (FBSDKShareDialogMode)getDialogMode
|
|
{
|
|
switch (self.shareDialogMode) {
|
|
case ShareDialogMode::AUTOMATIC:
|
|
return FBSDKShareDialogModeAutomatic;
|
|
case ShareDialogMode::NATIVE:
|
|
return FBSDKShareDialogModeNative;
|
|
case ShareDialogMode::WEB:
|
|
return FBSDKShareDialogModeWeb;
|
|
case ShareDialogMode::FEED:
|
|
return FBSDKShareDialogModeFeedWeb;
|
|
default:
|
|
NSLog(@"Unexpected dialog mode: %@", [NSNumber numberWithInt:self.shareDialogMode]);
|
|
return FBSDKShareDialogModeAutomatic;
|
|
}
|
|
}
|
|
|
|
- (BOOL)tryCompleteLoginWithRequestId:(int) requestId
|
|
{
|
|
NSMutableDictionary *userData = [[NSMutableDictionary alloc] init];
|
|
NSDictionary *accessTokenUserData = [self getAccessTokenUserData];
|
|
NSDictionary *authenticationTokenUserData = [self getAuthenticationTokenUserData];
|
|
if (accessTokenUserData) {
|
|
[userData addEntriesFromDictionary:accessTokenUserData];
|
|
}
|
|
if (authenticationTokenUserData) {
|
|
[userData addEntriesFromDictionary:authenticationTokenUserData];
|
|
}
|
|
if (userData) {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnLoginComplete
|
|
userData:[userData copy]
|
|
requestId:requestId];
|
|
return YES;
|
|
} else {
|
|
return NO;
|
|
}
|
|
}
|
|
|
|
- (NSDictionary *)getAccessTokenUserData
|
|
{
|
|
FBSDKAccessToken *token = [FBSDKAccessToken currentAccessToken];
|
|
if (token) {
|
|
// Old v3 sdk tokens don't always contain a UserID. If the user ID is null
|
|
// treat the token as bad and clear it. These values are all required
|
|
// on c# side for initlizing a token.
|
|
NSDictionary *userData = [FBUnityUtility getUserDataFromAccessToken:token];
|
|
if (userData) {
|
|
return userData;
|
|
} else {
|
|
// The token is missing a required value. Clear the token
|
|
[[[FBSDKLoginManager alloc] init] logOut];
|
|
}
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
- (NSDictionary *)getAuthenticationTokenUserData
|
|
{
|
|
FBSDKAuthenticationToken *token = [FBSDKAuthenticationToken currentAuthenticationToken];
|
|
if (token.tokenString && token.nonce) {
|
|
return @{
|
|
@"auth_token_string": token.tokenString,
|
|
@"auth_nonce": token.nonce
|
|
};
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
@end
|
|
|
|
#pragma mark - Actual Unity C# interface (extern C)
|
|
|
|
extern "C" {
|
|
|
|
void IOSFBSendViewHierarchy(const char *_tree )
|
|
{
|
|
Class FBUnityUtility = NSClassFromString(@"FBSDKCodelessIndexer");
|
|
[FBUnityUtility performSelector:NSSelectorFromString(@"uploadIndexing:")
|
|
withObject:[NSString stringWithUTF8String:_tree]];
|
|
}
|
|
|
|
void IOSFBInit(const char *_appId, bool _frictionlessRequests, const char *_urlSuffix, const char *_userAgentSuffix)
|
|
{
|
|
// Set the user agent before calling init to ensure that calls made during
|
|
// init use the user agent suffix.
|
|
[FBSDKSettings.sharedSettings setUserAgentSuffix:[FBUnityUtility stringFromCString:_userAgentSuffix]];
|
|
|
|
[[FBUnityInterface sharedInstance] configureAppId:_appId
|
|
frictionlessRequests:_frictionlessRequests
|
|
urlSuffix:_urlSuffix];
|
|
[[FBSDKAppEvents shared] setIsUnityInitialized:true];
|
|
[[FBSDKAppEvents shared] sendEventBindingsToUnity];
|
|
}
|
|
|
|
void IOSFBEnableProfileUpdatesOnAccessTokenChange(bool enable)
|
|
{
|
|
[FBSDKProfile enableUpdatesOnAccessTokenChange:enable];
|
|
}
|
|
|
|
void IOSFBLoginWithTrackingPreference(int requestId, const char *scope, const char *tracking, const char *nonce)
|
|
{
|
|
[[FBUnityInterface sharedInstance] loginWithTrackingPreference:requestId scope:scope
|
|
tracking:tracking
|
|
nonce:nonce];
|
|
}
|
|
|
|
void IOSFBLogInWithReadPermissions(int requestId,
|
|
const char *scope)
|
|
{
|
|
[[FBUnityInterface sharedInstance] logInWithReadPermissions:requestId scope:scope];
|
|
}
|
|
|
|
void IOSFBLogInWithPublishPermissions(int requestId,
|
|
const char *scope)
|
|
{
|
|
[[FBUnityInterface sharedInstance] logInWithPublishPermissions:requestId scope:scope];
|
|
}
|
|
|
|
void IOSFBLogOut()
|
|
{
|
|
[[FBUnityInterface sharedInstance] logOut];
|
|
}
|
|
|
|
char* IOSFBCurrentAuthenticationToken()
|
|
{
|
|
FBSDKAuthenticationToken *token = [FBSDKAuthenticationToken currentAuthenticationToken];
|
|
NSString *str = @"";
|
|
if (token.tokenString && token.nonce) {
|
|
try {
|
|
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:@{
|
|
@"auth_token_string": token.tokenString,
|
|
@"auth_nonce": token.nonce
|
|
} options:NSJSONWritingPrettyPrinted error:nil];
|
|
if (jsonData) {
|
|
str = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
|
|
}
|
|
} catch (NSException *exception) {
|
|
NSLog(@"Fail to parse AuthenticationToken");
|
|
}
|
|
}
|
|
const char* string = [str UTF8String];
|
|
char* res = (char*)malloc(strlen(string) + 1);
|
|
strcpy(res, string);
|
|
return res;
|
|
}
|
|
|
|
char* IOSFBCurrentProfile()
|
|
{
|
|
FBSDKProfile *profile = [FBSDKProfile currentProfile];
|
|
NSString *str = @"";
|
|
NSMutableDictionary<NSString *, id> *data = [NSMutableDictionary new];
|
|
if (profile.userID) {
|
|
data[@"userID"] = profile.userID;
|
|
}
|
|
if (profile.firstName) {
|
|
data[@"firstName"] = profile.firstName;
|
|
}
|
|
if (profile.middleName) {
|
|
data[@"middleName"] = profile.middleName;
|
|
}
|
|
if (profile.lastName) {
|
|
data[@"lastName"] = profile.lastName;
|
|
}
|
|
if (profile.name) {
|
|
data[@"name"] = profile.name;
|
|
}
|
|
if (profile.email) {
|
|
data[@"email"] = profile.email;
|
|
}
|
|
if (profile.imageURL) {
|
|
data[@"imageURL"] = profile.imageURL.absoluteString;
|
|
}
|
|
if (profile.linkURL) {
|
|
data[@"linkURL"] = profile.linkURL.absoluteString;
|
|
}
|
|
if (profile.friendIDs) {
|
|
data[@"friendIDs"] = [profile.friendIDs componentsJoinedByString:@","];
|
|
}
|
|
if (profile.birthday) {
|
|
data[@"birthday"] = [NSString stringWithFormat:@"%@", @((time_t)[profile.birthday timeIntervalSince1970])];
|
|
}
|
|
if (profile.ageRange) {
|
|
if (profile.ageRange.min) {
|
|
data[@"ageMin"] = profile.ageRange.min.stringValue;
|
|
}
|
|
if (profile.ageRange.max) {
|
|
data[@"ageMax"] = profile.ageRange.max.stringValue;
|
|
}
|
|
}
|
|
|
|
if (profile.hometown) {
|
|
data[@"hometown_id"] = profile.hometown.id;
|
|
data[@"hometown_name"] = profile.hometown.name;
|
|
}
|
|
|
|
if (profile.location) {
|
|
data[@"location_id"] = profile.location.id;
|
|
data[@"location_name"] = profile.location.name;
|
|
}
|
|
|
|
if (profile.gender) {
|
|
data[@"gender"] = profile.gender;
|
|
}
|
|
|
|
try {
|
|
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:data options:NSJSONWritingPrettyPrinted error:nil];
|
|
if (jsonData) {
|
|
str = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
|
|
}
|
|
} catch (NSException *exception) {
|
|
NSLog(@"Fail to parse Profile");
|
|
}
|
|
const char* string = [str UTF8String];
|
|
char* res = (char*)malloc(strlen(string) + 1);
|
|
strcpy(res, string);
|
|
return res;
|
|
}
|
|
|
|
void IOSFBSetPushNotificationsDeviceTokenString(const char *token)
|
|
{
|
|
[[FBSDKAppEvents shared] setPushNotificationsDeviceTokenString:[FBUnityUtility stringFromCString:token]];
|
|
}
|
|
|
|
void IOSFBSetShareDialogMode(int mode)
|
|
{
|
|
[FBUnityInterface sharedInstance].shareDialogMode = static_cast<ShareDialogMode>(mode);
|
|
}
|
|
|
|
void IOSFBAppRequest(int requestId,
|
|
const char *message,
|
|
const char *actionType,
|
|
const char *objectId,
|
|
const char **to,
|
|
int toLength,
|
|
const char *filters,
|
|
const char **excludeIds, //not supported on mobile
|
|
int excludeIdsLength, //not supported on mobile
|
|
bool hasMaxRecipients, //not supported on mobile
|
|
int maxRecipients, //not supported on mobile
|
|
const char *data,
|
|
const char *title)
|
|
{
|
|
[[FBUnityInterface sharedInstance] appRequestWithRequestId: requestId
|
|
message: message
|
|
actionType: actionType
|
|
objectId: objectId
|
|
to: to
|
|
toLength: toLength
|
|
filters: filters
|
|
data: data
|
|
title: title];
|
|
}
|
|
|
|
void IOSFBGetAppLink(int requestId)
|
|
{
|
|
NSURL *url = [NSURL URLWithString:[FBUnityInterface sharedInstance].openURLString];
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnGetAppLinkComplete
|
|
userData:[FBUnityUtility appLinkDataFromUrl:url]
|
|
requestId:requestId];
|
|
[FBUnityInterface sharedInstance].openURLString = nil;
|
|
}
|
|
|
|
void IOSFBShareLink(int requestId,
|
|
const char *contentURL,
|
|
const char *contentTitle,
|
|
const char *contentDescription,
|
|
const char *photoURL)
|
|
{
|
|
[[FBUnityInterface sharedInstance] shareLinkWithRequestId:requestId
|
|
contentURL:contentURL
|
|
contentTitle:contentTitle
|
|
contentDescription:contentDescription
|
|
photoURL:photoURL];
|
|
}
|
|
|
|
void IOSFBFeedShare(int requestId,
|
|
const char *toId,
|
|
const char *link,
|
|
const char *linkName,
|
|
const char *linkCaption,
|
|
const char *linkDescription,
|
|
const char *picture,
|
|
const char *mediaSource)
|
|
{
|
|
[[FBUnityInterface sharedInstance] shareFeedWithRequestId:requestId
|
|
toId:toId
|
|
link:link
|
|
linkName:linkName
|
|
linkCaption:linkCaption
|
|
linkDescription:linkDescription
|
|
picture:picture
|
|
mediaSource:mediaSource];
|
|
}
|
|
|
|
void IOSFBAppEventsActivateApp()
|
|
{
|
|
[FBSDKAppEvents.shared activateApp];
|
|
}
|
|
|
|
void IOSFBAppEventsLogEvent(const char *eventName,
|
|
double valueToSum,
|
|
int numParams,
|
|
const char **paramKeys,
|
|
const char **paramVals)
|
|
{
|
|
NSDictionary *params = [FBUnityUtility dictionaryFromKeys:paramKeys values:paramVals length:numParams];
|
|
[[FBSDKAppEvents shared] logEvent:[FBUnityUtility stringFromCString:eventName] valueToSum:valueToSum parameters:params];
|
|
}
|
|
|
|
void IOSFBAppEventsLogPurchase(double amount,
|
|
const char *currency,
|
|
int numParams,
|
|
const char **paramKeys,
|
|
const char **paramVals)
|
|
{
|
|
NSDictionary *params = [FBUnityUtility dictionaryFromKeys:paramKeys values:paramVals length:numParams];
|
|
[[FBSDKAppEvents shared] logPurchase:amount currency:[FBUnityUtility stringFromCString:currency] parameters:params];
|
|
}
|
|
|
|
void IOSFBAppEventsSetLimitEventUsage(BOOL limitEventUsage)
|
|
{
|
|
[FBSDKSettings.sharedSettings setIsEventDataUsageLimited:limitEventUsage];
|
|
}
|
|
|
|
void IOSFBAutoLogAppEventsEnabled(BOOL autoLogAppEventsEnabledID)
|
|
{
|
|
[FBSDKSettings.sharedSettings setAutoLogAppEventsEnabled:autoLogAppEventsEnabledID];
|
|
}
|
|
|
|
void IOSFBAdvertiserIDCollectionEnabled(BOOL advertiserIDCollectionEnabledID)
|
|
{
|
|
[FBSDKSettings.sharedSettings setAdvertiserIDCollectionEnabled:advertiserIDCollectionEnabledID];
|
|
}
|
|
|
|
BOOL IOSFBAdvertiserTrackingEnabled(BOOL advertiserTrackingEnabled)
|
|
{
|
|
[FBSDKSettings.sharedSettings setAdvertiserTrackingEnabled:advertiserTrackingEnabled];
|
|
return [FBSDKSettings.sharedSettings isAdvertiserTrackingEnabled];
|
|
}
|
|
|
|
char* IOSFBSdkVersion()
|
|
{
|
|
const char* string = [[FBSDKSettings.sharedSettings sdkVersion] UTF8String];
|
|
char* res = (char*)malloc(strlen(string) + 1);
|
|
strcpy(res, string);
|
|
return res;
|
|
}
|
|
|
|
void IOSFBSetUserID(const char *userID)
|
|
{
|
|
[[FBSDKAppEvents shared] setUserID:[FBUnityUtility stringFromCString:userID]];
|
|
}
|
|
|
|
void IOSFBOpenGamingServicesFriendFinder(int requestId)
|
|
{
|
|
[FBSDKFriendFinderDialog
|
|
launchFriendFinderDialogWithCompletionHandler:^(BOOL success, NSError * _Nullable error) {
|
|
if (!success || error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnFriendFinderComplete error:error requestId:requestId];
|
|
} else {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnFriendFinderComplete
|
|
userData:NULL
|
|
requestId:requestId];
|
|
}
|
|
}];
|
|
}
|
|
|
|
void IOSFBCreateGamingContext(int requestID, const char *playerID) {
|
|
NSError *error;
|
|
NSString *playerIDString = [FBUnityUtility stringFromCString:playerID];
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestID];
|
|
FBSDKCreateContextContent *content = [[FBSDKCreateContextContent alloc] initDialogContentWithPlayerID:playerIDString];
|
|
FBSDKContextDialogPresenter *presenter = [[FBSDKContextDialogPresenter alloc] init];
|
|
[presenter makeAndShowCreateContextDialogWithContent:content delegate:delegate error:&error];
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnGetTournamentsComplete error:error requestId:requestID];
|
|
}
|
|
}
|
|
|
|
void IOSFBSwitchGamingContext(
|
|
int requestID,
|
|
const char *contextID) {
|
|
NSError *error;
|
|
NSString *contextIDString = [FBUnityUtility stringFromCString:contextID];
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestID];
|
|
FBSDKSwitchContextContent *content = [[FBSDKSwitchContextContent alloc] initDialogContentWithContextID:contextIDString];
|
|
FBSDKContextDialogPresenter *presenter = [[FBSDKContextDialogPresenter alloc] init];
|
|
[presenter makeAndShowSwitchContextDialogWithContent:content delegate:delegate error:&error];
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnGetTournamentsComplete error:error requestId:requestID];
|
|
}
|
|
}
|
|
|
|
void IOSFBChooseGamingContext(
|
|
int requestID,
|
|
const char *filter,
|
|
int minSize,
|
|
int maxSize)
|
|
{
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestID];
|
|
FBSDKChooseContextContent *chooseContent = [FBSDKChooseContextContent alloc];
|
|
|
|
NSString *filterNSString = [NSString stringWithUTF8String:filter];
|
|
if ([filterNSString length] == 0) {
|
|
chooseContent.filter = FBSDKChooseContextFilterNone;
|
|
} else if ([filterNSString isEqualToString:@"NEW_PLAYERS_ONLY"]) {
|
|
chooseContent.filter = FBSDKChooseContextFilterNewPlayersOnly;
|
|
} else if ([filterNSString isEqualToString:@"INCLUDE_EXISTING_CHALLENGES"]) {
|
|
chooseContent.filter = FBSDKChooseContextFilterExistingChallenges;
|
|
} else if ([filterNSString isEqualToString:@"NEW_CONTEXT_ONLY"]) {
|
|
chooseContent.filter = FBSDKChooseContextFilterNewContextOnly;
|
|
}
|
|
|
|
if (minSize > 0) {
|
|
chooseContent.minParticipants = minSize;
|
|
}
|
|
if (maxSize > 0) {
|
|
chooseContent.maxParticipants = maxSize;
|
|
}
|
|
|
|
FBSDKContextDialogPresenter *presenter = [[FBSDKContextDialogPresenter alloc] init];
|
|
[presenter makeAndShowChooseContextDialogWithContent:chooseContent delegate:delegate];
|
|
}
|
|
|
|
void IOSFBGetCurrentGamingContext(int requestID)
|
|
{
|
|
FBSDKGamingContext *currentContext = [FBSDKGamingContext currentContext];
|
|
if (currentContext) {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnGetCurrentGamingContextComplete
|
|
userData:@{@"contextId":[currentContext identifier]}
|
|
requestId:requestID];
|
|
} else {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnGetCurrentGamingContextComplete
|
|
userData:NULL
|
|
requestId:requestID];
|
|
}
|
|
}
|
|
|
|
void IOSFBSetDataProcessingOptions(
|
|
const char** options,
|
|
int numOptions,
|
|
int country,
|
|
int state) {
|
|
NSMutableArray<NSString*>* array = [[NSMutableArray alloc] init];
|
|
for (int i = 0; i < numOptions; i++) {
|
|
NSString* option = [FBUnityUtility stringFromCString:options[i]];
|
|
if (option) {
|
|
[array addObject:option];
|
|
}
|
|
}
|
|
[FBSDKSettings.sharedSettings setDataProcessingOptions:array country:country state:state];
|
|
}
|
|
|
|
void IOSFBGetTournaments(int requestID)
|
|
{
|
|
FBSDKTournamentFetcher *fetcher = [[FBSDKTournamentFetcher alloc] init];
|
|
[fetcher fetchTournamentsWithCompletionHandler:^(NSArray<FBSDKTournament *> * tournaments, NSError * error) {
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnGetTournamentsComplete error:error requestId:requestID];
|
|
}
|
|
|
|
NSMutableDictionary *userData = [NSMutableDictionary new];
|
|
for (FBSDKTournament *tournament in tournaments) {
|
|
userData[tournament.identifier] = [tournament toDictionary];
|
|
}
|
|
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnGetTournamentsComplete
|
|
userData:userData
|
|
requestId:requestID];
|
|
}];
|
|
}
|
|
|
|
void IOSFBUpdateTournament(const char *tournamentID, int score, int requestID)
|
|
{
|
|
FBSDKTournamentUpdater *updater = [[FBSDKTournamentUpdater alloc] init];
|
|
[updater updateWithTournamentID:[NSString stringWithUTF8String:tournamentID]
|
|
score:score
|
|
completionHandler:^(BOOL success, NSError * _Nullable error) {
|
|
if (!success || error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnUpdateTournamentComplete error:error requestId:requestID];
|
|
} else {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnUpdateTournamentComplete
|
|
userData:NULL
|
|
requestId:requestID];
|
|
}
|
|
}];
|
|
}
|
|
|
|
void IOSFBUpdateAndShareTournament(const char *tournamentID, int score, int requestID)
|
|
{
|
|
NSError *error;
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestID];
|
|
FBSDKShareTournamentDialog *dialog = [[FBSDKShareTournamentDialog alloc] initWithDelegate: delegate];
|
|
[dialog showWithScore:score tournamentID:[NSString stringWithUTF8String:tournamentID] error:&error];
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnGetTournamentsComplete error:error requestId:requestID];
|
|
}
|
|
}
|
|
|
|
void IOSFBCreateAndShareTournament(
|
|
int initialScore,
|
|
const char *title,
|
|
int sortOrder,
|
|
int scoreFormat,
|
|
long endTime,
|
|
const char *payload,
|
|
int requestID)
|
|
{
|
|
NSError *error;
|
|
FBUnitySDKDelegate *delegate = [FBUnitySDKDelegate instanceWithRequestID:requestID];
|
|
FBSDKShareTournamentDialog *dialog = [[FBSDKShareTournamentDialog alloc] initWithDelegate: delegate];
|
|
NSString *payloadString;
|
|
if (payload) {
|
|
payloadString = [NSString stringWithUTF8String:payload];
|
|
}
|
|
[dialog showWithInitialScore:initialScore
|
|
title:[NSString stringWithUTF8String:title]
|
|
endTime:[NSDate dateWithTimeIntervalSince1970: endTime]
|
|
scoreType:scoreFormat
|
|
sortOrder:sortOrder
|
|
payload:payloadString
|
|
error: &error];
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnGetTournamentsComplete error:error requestId:requestID];
|
|
}
|
|
}
|
|
|
|
void IOSFBUploadImageToMediaLibrary(
|
|
int requestId,
|
|
const char *caption,
|
|
const char *imageUri,
|
|
bool shouldLaunchMediaDialog)
|
|
{
|
|
NSString *captionString = [FBUnityUtility stringFromCString:caption];
|
|
NSString *imageUriString = [FBUnityUtility stringFromCString:imageUri];
|
|
UIImage *image = [UIImage imageWithContentsOfFile:imageUriString];
|
|
|
|
FBSDKGamingImageUploaderConfiguration *config =
|
|
[[FBSDKGamingImageUploaderConfiguration alloc]
|
|
initWithImage:image
|
|
caption:captionString
|
|
shouldLaunchMediaDialog:shouldLaunchMediaDialog ? YES: NO];
|
|
|
|
[FBSDKGamingImageUploader
|
|
uploadImageWithConfiguration:config
|
|
andResultCompletion:^(BOOL success, id result, NSError * _Nullable error) {
|
|
if (!success || error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnUploadImageToMediaLibraryComplete
|
|
error:error
|
|
requestId:requestId];
|
|
} else {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnUploadImageToMediaLibraryComplete
|
|
userData:@{@"id":result[@"id"]}
|
|
requestId:requestId];
|
|
}
|
|
}];
|
|
|
|
}
|
|
|
|
void IOSFBUploadVideoToMediaLibrary(int requestId,
|
|
const char *caption,
|
|
const char *videoUri)
|
|
{
|
|
NSString *captionString = [FBUnityUtility stringFromCString:caption];
|
|
NSString *videoUriString = [FBUnityUtility stringFromCString:videoUri];
|
|
NSURL *videoURL = [NSURL fileURLWithPath:videoUriString];
|
|
|
|
FBSDKGamingVideoUploaderConfiguration *config =
|
|
[[FBSDKGamingVideoUploaderConfiguration alloc]
|
|
initWithVideoURL:videoURL
|
|
caption:captionString];
|
|
|
|
[FBSDKGamingVideoUploader
|
|
uploadVideoWithConfiguration:config
|
|
andResultCompletion:^(BOOL success, id result, NSError * _Nullable error) {
|
|
if (!success || error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnUploadVideoToMediaLibraryComplete
|
|
error:error
|
|
requestId:requestId];
|
|
} else {
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnUploadVideoToMediaLibraryComplete
|
|
userData:@{@"id":result[@"id"]}
|
|
requestId:requestId];
|
|
}
|
|
}];
|
|
|
|
}
|
|
|
|
char* IOSFBGetUserID()
|
|
{
|
|
NSString *userID = [[FBSDKAppEvents shared] userID];
|
|
if (!userID) {
|
|
return NULL;
|
|
}
|
|
const char* string = [userID UTF8String];
|
|
char* res = (char*)malloc(strlen(string) + 1);
|
|
strcpy(res, string);
|
|
return res;
|
|
}
|
|
|
|
void IOSFBFetchDeferredAppLink(int requestId)
|
|
{
|
|
[FBSDKAppLinkUtility fetchDeferredAppLink:^(NSURL *url, NSError *error) {
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnFetchDeferredAppLinkComplete error:error requestId:requestId];
|
|
return;
|
|
}
|
|
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnFetchDeferredAppLinkComplete
|
|
userData:[FBUnityUtility appLinkDataFromUrl:url]
|
|
requestId:requestId];
|
|
}];
|
|
}
|
|
|
|
void IOSFBRefreshCurrentAccessToken(int requestId)
|
|
{
|
|
FBSDKGraphRequestCompletion completion = ^(id<FBSDKGraphRequestConnecting> connection, id result, NSError *error) {
|
|
if (error) {
|
|
[FBUnityUtility sendErrorToUnity:FBUnityMessageName_OnRefreshCurrentAccessTokenComplete error:error requestId:requestId];
|
|
return;
|
|
}
|
|
|
|
[FBUnityUtility sendMessageToUnity:FBUnityMessageName_OnRefreshCurrentAccessTokenComplete
|
|
userData:[FBUnityUtility getUserDataFromAccessToken:[FBSDKAccessToken currentAccessToken]]
|
|
requestId:requestId];
|
|
};
|
|
[FBSDKAccessToken refreshCurrentAccessTokenWithCompletion: completion];
|
|
}
|
|
}
|