Add-on Facebook module.

The Facebook module is used for connecting your application with Facebook. This module supports the following features:

• Logging in to Facebook and authorizing your application with either the Login button or programatically.

• Making requests through the Facebook Graph API using the requestWithGraphPath() method.

• Sharing content using Facebook dialogs or the Like button.

Using Ti.Facebook with iOS 10 and Xcode 8

The paragraph about custom capabilities was only necessary between Titanium SDK 5.5.0 and 6.0.0. Since 6.0.1.GA, we add the required capabilities automatically, so you don't need to curate your own entitlements file anymore, which will avoid possible issues with concurring values. Please ensure to use both SDK and CLI 6.0.1 (or later).

Note: As of April 30th, 2015, Facebook no longer supports version 1.0 of their API, which includes the FQL and REST APIs. Only the Graph APIs will be supported.

Migration from the Facebook module v4.x to v5.x

• dialog() method -- presentWebShareDialog() is deprecated and removed. The module will auto determine if you have a native Facebook App installed. canPresentShareDialog() is also deprecated and removed. For more details, see 'Share Dialogs' and 'Request Dialogs' below.

• presentShareDialog() method -- 'name' parameter is deprecated and replaced with 'title'. 'caption' parameter is deprecated and removed.

• presentSendRequestDialog() method -- 'to' parameter is deprecated and replaced with 'recipients'. There are a few new parameters as well, for more details, see presentSendRequestDialog()

The following APIs were removed due to changes in the native Facebook SDKs and removal of the Facebook v1.0 REST APIs:

• appid property -- The Facebook application ID can no longer be set programmatically in the application. Set the Facebook application ID in the tiapp.xml file. For more details, see 'Getting Started' below for more details. Migration from the Facebook module v3.x to v4.x

The following APIs were removed due to changes in the native Facebook SDKs and removal of the Facebook v1.0 REST APIs:

• appid property -- The Facebook application ID can no longer be set programmatically in the application. Set the Facebook application ID in the tiapp.xml file. For more details, see 'Getting Started' below for more details.

• dialog() method -- Use either presentSendRequestDialog(), presentInviteDialog(), presentMessengerDialog(), presentShareDialog() or presentWebShareDialog(). For more details, see 'Share Dialogs' and 'Request Dialogs' below.

• forceDialogAuth property -- On Android, you can force dialog authorization with the LoginButton.sessionLoginBehavior property.

• publishInstall() method -- The underlying Facebook API has been deprecated and is now handled automatically by the module.

• request() method -- Due to the removal of the Facebook v1.0 APIs, all applications should call the Graph APIs instead. If you make any REST API calls with the request() method, transition to the Graph APIs and use the requestWithGraphPath() method.

• reauthorize() method -- To request additional Facebook permissions once the user authorizes the application, use either the requestNewReadPermissions() or requestNewPublishPermissions(). For more details, see "Manage Read and Write Permissions" below.

• LoginButton style property -- Facebook redesigned its Login button and the style can no longer be changed.

• Places API -- Fetch nearby places using the current location or a specified search-tearm.

Getting Started

To use the Facebook module, you need a Facebook application. To create a Facebook App, go to the Facebook Developer App: developers.facebook.com/apps.

• Edit the modules section of your tiapp.xml file to include this module:

  <modules>
      <!-- Add the appropriate line(s) to your modules section -->
      <module platform="android">facebook</module>
      <module platform="iphone">facebook</module>
  </modules>
  

• Instantiate the module with the require('facebook') method, then make subsequent API calls with the new Facebook object.

   var fb = require('facebook');
   fb.permissions = [FACEBOOK_APP_PERMISSIONS]; // e.g. ['email']
   fb.initialize();
   fb.authorize();
  

Additional iOS Setup Steps

For the iOS platform, in the ios plist dict section of your tiapp.xml file, add the following keys:

• FacebookAppID key with your Facebook App ID as the string value
• FacebookDisplayName key with your Facebook App name (the one from developer.facebook.com) as the string value
• CFBundleURLTypes key with a single-element array containing a dict as the value, where the dict contains:
  • CFBundleURLName key with the application app ID (same value as the id in the tiapp.xml file) as the string value
  • CFBundleURLSchemes key with a single-element array containing the Facebook App ID prefixed with fb as a string value

For example:

    <ti:app>
        <ios>
            <plist>
                <dict>
                    <key>CFBundleURLTypes</key>
                    <array>
                        <dict>
                            <key>CFBundleURLName</key>
                            <!-- Application ID same as the id value in the tiapp.xml file -->
                            <string>APP_ID</string>
                            <key>CFBundleURLSchemes</key>
                            <array>
                                <!-- Prefix the Facebook App ID with 'fb' -->
                                <string>fbFACEBOOK_APP_ID</string>
                            </array>
                        </dict>
                    </array>
                    <key>FacebookAppID</key>
                    <!-- Facebook App ID -->
                    <string>FACEBOOK_APP_ID</string>
                    <key>FacebookDisplayName</key>
                    <!-- Facebook App Name from developer.facebook.com -->
                    <string>FACEBOOK_APP_NAME</string>
                </dict>
            </plist>
        </ios>
    </ti:app>

To enable the use of Facebook dialogs (e.g., Login, Share), you also need to include the following key and values in tiapp.xml to handle the switching in and out of your app:

<key>LSApplicationQueriesSchemes</key>
<array>
    <string>fbapi</string>
    <string>fb-messenger-api</string>
    <string>fbauth2</string>
    <string>fbshareextension</string>
</array>

If you are using the older Ti.Facebook Module 4.0.5 and wish to support iOS9, you will instead need to include the following key and values in tiapp.xml to handle the switching in and out of your app:

<key>LSApplicationQueriesSchemes</key>
<array>
    <string>fbapi</string>
    <string>fbapi20130214</string>
    <string>fbapi20130410</string>
    <string>fbapi20130702</string>
    <string>fbapi20131010</string>
    <string>fbapi20131219</string>
    <string>fbapi20140410</string>
    <string>fbapi20140116</string>
    <string>fbapi20150313</string>
    <string>fbapi20150629</string>
    <string>fbauth</string>
    <string>fbauth2</string>
    <string>fb-messenger-api20140430</string>
</array>

For iOS9 and titanium 5.0.0.GA and above, App Transport Security is disabled by default. If you choose to enable it, you have to set the following keys and values in tiapp.xml section for facebook module:

<key>NSAppTransportSecurity</key>
<dict>
    <key>NSExceptionDomains</key>
        <dict>
            <key>facebook.com</key>
                <dict>
                    <key>NSIncludesSubdomains</key> 
                    <true/>
                    <key>NSExceptionRequiresForwardSecrecy</key> 
                    <false/>
                </dict>
            <key>fbcdn.net</key>
                <dict>
                    <key>NSIncludesSubdomains</key> 
                    <true/>
                    <key>NSExceptionRequiresForwardSecrecy</key>  
                    <false/>
                </dict>
            <key>akamaihd.net</key>
                <dict>
                    <key>NSIncludesSubdomains</key> 
                    <true/>
                    <key>NSExceptionRequiresForwardSecrecy</key> 
                    <false/>
                </dict>
        </dict>
</dict>

Additional Android Setup Steps

Since Facebook module v4.0.0, for the Android platform, you need to:

• Add the Facebook Login activity to the Android manifest
• Add the Facebook App ID to the Android resources string.xml file
• Create a Facebook proxy and associate it with the current active activity

Modify the Android Manifest

Add the Facebook Login activity to the android manifest section of your tiapp.xml file. You may need to add the manifest and application elements.

<ti:app>
    <android xmlns:android="http://schemas.android.com/apk/res/android">
        <manifest>
            <application>
                <activity android:name="com.facebook.FacebookActivity" 
                          android:theme="@android:style/Theme.Translucent.NoTitleBar" 
                          android:label="YourAppName" 
                          android:configChanges="keyboard|keyboardHidden|screenLayout|screenSize|orientation" />
                <meta-data android:name="com.facebook.sdk.ApplicationId" android:value="@string/facebook_app_id"/>
            </application>
        </manifest>
    </android>
<ti:app>

Add the Facebook App ID to Android Resources

Add a string element to the /platform/android/res/values/strings.xml file with the name attribute set to facebook_app_id and the node text set to your Facebook App ID. Create the file if it does not exist.

<resources>
    <string name="facebook_app_id">FACEBOOK_APP_ID</string>
</resources>

Create a Facebook Proxy

Use the createActivityWorker() method to create a Facebook proxy. Pass the method a dictionary with the lifecycleContainer property set to the current active instance of a standalone Window (window not contained in a tab group) or TabGroup. Create the proxy before calling the open() method on either the window or tab group.

The Facebook module needs to hook into the lifecycle events of the current active activity in order to synchronize its state between various activities in the application, for example, to update the label of the Login button when the user logs in or out of Facebook.

Attach the proxy to the Window or TabGroup object, so it does not get garbage collected.

win.fbProxy = fb.createActivityWorker({lifecycleContainer: win});

Module API Usage

Facebook Login and Authorization

To use Facebook, a user must logged into Facebook and explicitly authorize the application to perform certain actions, such as accessing profile information or posting status messages.

There are two ways to initiate the login process:

• Call authorize to prompt the user to login and authorize the application. Before calling this method, set the permissions property if additional permissions are needed.

• Create a Facebook LoginButton to allow the user to log in if desired. You can add either read permissions or write permissions, otherwise the default is to request for the public_profile permission. Note that Facebook does not support setting both readPermissions and publishPermissions properties at the same time when using the LoginButton.

Which approach you take depends on your UI and how central Facebook is to your application.

Manage Read and Write Permissions

In order to read or write content to a user's Facebook page, you need to request permission from the user. You can either request permissions when the user authorizes your application or request permissions on the fly.

Before the user logs in and authorizes the application, you can request permissions for the application to use by either:

• Setting the permissions property if you are using authorize() method to have the user login and authorize the application.
• Setting either the readPermissions or publishPermissions on an instance of a LoginButton. Do not set both properties or the application will throw an error.

For a complete list of permissions, see the official Facebook Permissions Reference

Refresh Application Permissions

Since the user can selectively turn application permissions on and off from their Facebook page, the application may need to refresh its granted permissions.

To refresh the application's permissions, call the refreshPermissionsFromServer() method, then listen for the tokenUpdated event to be notified when permissions are updated.

fb.addEventListener('tokenUpdated', function(e) {
    Ti.API.info('Updated permissions: ' + JSON.stringify(fb.permissions));
});
fb.refreshPermissionsFromServer();

Request Additional Read Permissions

To request additional read permissions once the user authorizes your application, use the requestNewReadPermissions() method.

Check the permissions property to make sure the user accepted the request for additional permissions.

var fb = require('facebook');
fb.requestNewReadPermissions(['read_stream','user_hometown', etc...], function(e) {
    if (e.success) {
        fb.requestWithGraphPath(...);
    } else if (e.cancelled) {
        ....
    } else {
        Ti.API.debug('Failed authorization due to: ' + e.error);
    }
});

Request Additional Write Permissions

To request additional write permissions once the user authorizes your application, use the requestNewPublishPermissions() method. Note that in addition to passing the permissions to request, you need to also pass an AUDIENCE_* constant to indicate the default audience when positing content.

Check the permissions property to make sure the user accepted the request for additional permissions.

var fb = require('facebook');
fb.requestNewPublishPermissions(['read_stream','user_hometown', etc...], fb.AUDIENCE_FRIENDS, function(e) {
    if (e.success) {
        fb.requestWithGraphPath(...);
    } else if (e.cancelled) {
    ....
    } else {
        Ti.API.debug('Failed authorization due to: ' + e.error);
    }
});

Share Dialogs

The Share dialog prompts a person to publish an individual story or an Open Graph story to their timeline. This does not require the user to authorize your app or any extended permissions, so it is the easiest way to enable sharing.

The Share dialog uses the Facebook apps interface, so the Facebook app needs to be installed. If the Facebook app is not installed, the application can use the Feed dialog that presents the dialog in a web-based view as a back up if the Share dialog is not available.

To present a Share dialog to a user, use the canPresentShareDialog property to check if the application can use the Share dialog. If the application supports the Share dialog, call the presentShareDialog() to present it, else call the presentWebShareDialog() method to present the Feed dialog.

Pass either method parameters you want to add to the post, such as a link or hashtag, or to share the user's status, do not pass any parameters to the methods.

To monitor if the share request succeeded or not, listen to the shareCompleted event. It uses the same arguments as presentMessengerDialog.

    fb.addEventListener('shareCompleted', function (e) {
        if (e.success) {
            Ti.API.info('Share request succeeded.');
        } else {
            Ti.API.warn('Failed to share.');
        }
    });

    fb.presentShareDialog({
        link: 'https://appcelerator.com/',
        hashtag: 'codestrong'
    });

For details on the Share dialog, see the official Facebook Share Dialogs documentation.

Requests Dialog

A request dialog allows a user to invite another user to use your application. Facebook will send a private message to the recipient. The typical use case is to invite another user to play a game. If you want to invite people to your application which is not a game, use the presentInviteDialog() method instead.

To send a request to a user, call the presentSendRequestDialog() method and pass the method a dictionary with the message property set the message you want to send the invited user. Optional: You can set the title property with a title string. You can also set the data property with a dictionary of custom parameters. If you want to preselect users to send invite to, you can set the to property with string of values that are facebook ids seperated by comma.

To monitor if the request succeeded or not, listen to the requestDialogCompleted event.

    fb.addEventListener('requestDialogCompleted', function (e) {
        if (e.success) {
            Ti.API.info('request succeeded.');
        } else {
            Ti.API.warn('Failed to share.');
        }
    });

    fb.presentSendRequestDialog({
        message: 'Go to https://appcelerator.com/',
        title: 'Invitation to Appcelerator',
        recipients: ['123456789', '123456788'],
        data: {
            badge_of_awesomeness: '1',
            social_karma: '5'
        }
    });

For details on request dialogs see the official Facebook Request Dialogs documentation.

Messenger Dialog

A messenger dialog allows a user to send content to the Facebook Messenger using your application.

To send a message to a user, call the presentMessengerDialog() method and pass the method a dictionary with the optional values "hashtag", "link", "to", "placeID" and "referal". It uses the same arguments as presentShareDialog.

    fb.presentMessengerDialog({
        link: "https://appcelerator.com", // The link you want to share
        referal: "ti_app", // The referal to be added as a suffix to your link
        placeID: "my_id", // The ID for a place to tag with this content
        to: [] // List of IDs for taggable people to tag with this content
    });

For details on dialog see the official Facebook Messenger Dialogs documentation.

Messenger Button

The Messenger button provides a quick mechanism for users to share content to the Facebook Messenger. A click on the button can share the content to multiple users.

To create a Messenger button, call the createMessengerButton() method and pass the "mode" and "style" properties:

var messengerButton = fb.createMessengerButton({
    mode: fb.MESSENGER_BUTTON_MODE_RECTANGULAR
    style: fb.MESSENGER_BUTTON_STYLE_BLUE
});
win.add(messengerButton);

For more information, see the MessengerButton API reference.

Like Button

The Like button provides a quick mechanism for users to share content. A click on the button will share the content on the user's Facebook page.

To create a Like button, call the createLikeButton() method and pass it a dictionary with the objectID assigned to either a URL or Open Graph object ID you want to share. Add the button instance to a view to display it.

var likeButton = fb.createLikeButton({
    objectID: "https://www.facebook.com/appcelerator"
});
win.add(likeButton);

For more information, see the LikeButton API reference.

Fetch Places

The Facebook SDK supports fetching places since Graph API v2.9. You are able to use the official FBSDKPlacesKit API in Titanium SDK 6.2.0 and later to fetch places by the current user location or a specified search tearm. Example of using the current location:

fb.fetchNearbyPlacesForCurrentLocation({
    confidenceLevel: fb.PLACE_LOCATION_CONFIDENCE_NOT_APPLICABLE, // optional
    fields: [], // optional, see https://developers.facebook.com/docs/places/fields
    success: function(e) {
        alert('Successfully fetched places!');
        Ti.API.info(e);
    },
    error: function(e) {
        alert('Error fetching places!');
        Ti.API.error(e);
    }
}); 

Check out the full example in examples/facebook_places.js.

Examples

Alloy Example

Displays the Facebook Login and Like buttons in a window.

app/alloy.js:

// Make API calls to Alloy.Globals.Facebook
Alloy.Globals.Facebook = require('facebook');

app/views/index.xml:

<Alloy>
    <Window backgroundColor="white">
        <LoginButton id="fbLogin" module="facebook" top="25" />
        <LikeButton id="fbLike" module="facebook" top="100" />
    </Window>
</Alloy>

app/controllers/index.js:

$.fbLike.objectID = "http://www.facebook.com/appcelerator";
if (OS_ANDROID) {
    $.index.fbProxy = Alloy.Globals.Facebook.createActivityWorker({lifecycleContainer: $.index});
}
$.index.open();

Authorize

Shows official Facebook dialog for logging in the user and prompting the user to approve your requested permissions. Listen for the module's login event to determine whether the request succeeded.

var fb = require('facebook');
fb.initialize();
fb.addEventListener('login', function(e) {
    if (e.success) {
        alert('login from uid: '+e.uid+', name: '+ JSON.parse(e.data).name);
        label.text = 'Logged In = ' + fb.loggedIn;
    }
    else if (e.cancelled) {
        // user cancelled
        alert('cancelled');
    }
    else {
        alert(e.error);
    }
});
fb.authorize();

Logout

Logout the user and forget the authorization token. The logout event is fired after the user is logged out.

fb.addEventListener('logout', function(e) {
    alert('Logged out');
});
fb.logout();

Authorize/Logout Using the Facebook LoginButton

You can use the the native Facebook LoginButton to allow the user to log in as required. The button updates its state automatically depending on whether the user is logged in or not. When the user is logged in, then the button will show "Logout", and vice-versa.

Note that you don't need to set a click listener or anything else on the button. To be notified when the user logs in or out, add event listeners for the login and logout events provided by the Facebook module, as in the example below.

// Don't forget to set your requested permissions, else the login button won't be effective.
var win = Ti.UI.createWindow({backgroundColor: 'white'});
var fb = require('facebook');

fb.addEventListener('login', function(e) {
    if (e.success) {
        alert('Logged in');
    }
});
fb.addEventListener('logout', function(e) {
    alert('Logged out');
});

if (Ti.Platform.name === 'android') {
    win.fbProxy = fb.createActivityWorker({lifecycleContainer: win});
}

// Add the button.  Note that it doesn't need a click event listener.
win.add(fb.createLoginButton({
        readPermissions: ['read_stream','email'],
        top: 50
}));

win.open()

Simple Graph API Call

This example makes a call to the "me" graph path, which represents the current user. The JSON results are simply displayed in an alert. This example assumes the user is already logged in. You can check this with loggedIn.

fb.requestWithGraphPath('me', {}, 'GET', function(e) {
    if (e.success) {
        alert(e.result);
    } else if (e.error) {
        alert(e.error);
    } else {
        alert('Unknown response');
    }
});

Post a Photo Using the Graph API from the Gallery.

This example posts a photo to the user's account using the Graph API. This requires the "publish_actions" permission.

var B1_TITLE = 'Upload Photo from Gallery with Graph API';
var b1 = Ti.UI.createButton({
    title:B1_TITLE,
    left: 10, right: 10, top: 0, height: 80
});

b1.addEventListener('click', function() {
    Titanium.Media.openPhotoGallery({
        success:function(event)
        {
            b1.title = 'Uploading Photo...';
            var data = {picture: event.media};
            // If publish_actions permission is not granted, request it
            if (fb.permissions.indexOf('publish_actions') < 0) {
                fb.requestNewPublishPermissions(['publish_actions'], fb.AUDIENCE_FRIENDS, function(e) {
                    if (e.success) {
                        Ti.API.info('Permissions:'+fb.permissions);
                        fb.requestWithGraphPath('me/photos', data, "POST", showRequestResult);
                    }
                    if (e.error) {
                        Ti.API.info('Publish permission error');
                    }
                    if (e.cancelled) {
                        Ti.API.info('Publish permission cancelled');
                    }
                });
            } else {
                fb.requestWithGraphPath('me/photos', data, "POST", showRequestResult);
            }
        },
        cancel:function()
        {
        },
        error:function(error)
        {
        },
        allowEditing:true
    });
});

For more information on posting photos, see:

• Photo in the Facebook Graph API Reference

Post a Photo Using the Graph API with an image in resources directory

This example posts a photo to the user's account using the Graph API. This requires the "publish_actions" permission.

var b2 = Ti.UI.createButton({
    title: 'Upload Photo from file with Graph API',
    left: 10, 
    right: 10, 
    top: 90, 
    height: 80
});

b2.addEventListener('click', function() {
    b2.title = 'Uploading Photo...';
    var f = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, 'images', 'flower.jpg');
    var blob = f.read();
    var data = {
        caption: 'behold, a flower',
        picture: blob
    };
    // If publish_actions permission is not granted, request it
    if (fb.permissions.indexOf('publish_actions') < 0) {
        fb.requestNewPublishPermissions(['publish_actions'], fb.AUDIENCE_FRIENDS, function(e) {
            if (e.success) {
                Ti.API.info('Permissions:'+fb.permissions);
                fb.requestWithGraphPath('me/photos', data, "POST", showRequestResult);
            }
            if (e.error) {
                Ti.API.info('Publish permission error');
            }
            if (e.cancelled) {
                Ti.API.info('Publish permission cancelled');
            }
        });
    } else {
        fb.requestWithGraphPath('me/photos', data, "POST", showRequestResult);
    }
});

For more information on posting photos, see:

• Photo in the Facebook Graph API Reference

Show the Share Dialog

This example shows how to use the Share Dialog.

var wallDialog = Ti.UI.createButton({
    title: 'Share URL with Share Dialog',
    top: 135, 
    left: 10, 
    right: 10, 
    height: 40
});

wallDialog.addEventListener('click', function() {
    if (fb.getCanPresentShareDialog()) {
        fb.presentShareDialog({
            link: 'https://appcelerator.com/',
            name: 'great product',
            description: 'Titanium is a great product',
            caption: 'it rocks too',
            picture: 'http://www.appcelerator.com/wp-content/uploads/scale_triangle1.png'
        });
    } else {
        fb.presentWebShareDialog({
            link: 'https://appcelerator.com/',
            name: 'great product',
            description: 'Titanium is a great product',
            caption: 'it rocks too',
            picture: 'http://www.appcelerator.com/wp-content/uploads/scale_triangle1.png'
        });
    }
});

For more information on Facebook Dialogs, see:

• Facebook Share Dialog Reference

Show the Invite Dialog

This example shows how to use the Invite Dialog.

var wallDialog = Ti.UI.createButton({
    title: 'Invite friends!',
    top: 135, 
    left: 10, 
    right: 10, 
    height: 40
});

wallDialog.addEventListener('click', function() {
    FB.presentInviteDialog({
        appLink: "https://fb.me/xxxxxxxx",
        appPreviewImageLink: "https://www.mydomain.com/my_invite_image.jpg"
    });
});

For more information on Invite Dialogs, see: Facebook Invite Dialog Reference

Share content to the Facebook Messenger

This example shows how to share images, GIF's and videos to the Facebook messenger.

var btn = Ti.UI.createButton({
    title: "Share media to messenger"
});
btn.addEventListener("click", function(e) {
    var media = [
        Ti.UI.createView({height: 30,width:30,backgroundColor: "#ff0"}).toImage(), // Image blob
        Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, "test.gif").read(), // GIF Blob
        Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, "movie.mp4").read() // Video Blob
    ];

    var options = Ti.UI.createOptionDialog({
        options: ["Photo", "GIF", "Video", "Cancel"],
        cancel: 3
    });
    options.addEventListener("click", function(e) {
        if (e.index == 3) {
            return;
        }
        FB.shareMediaToMessenger({
            media: media[e.index],
            metadata: "Ti rocks!",
            link: "https://appcelerator.com",
            //renderAsSticker: true // Only for photos e.g. selfies
        });
    });
    options.show();
});

For more information on sharing media to the Facebook Messenger, see:

• Facebook Messenger Reference

Requesting additional permissions

This example shows how to use the requestNewPublishPermissions method to request additional permissions to publish a post to the user's wall.

fb.requestNewPublishPermissions(['publish_actions'], fb.AUDIENCE_FRIENDS, function(e) {
    if (e.success) {
        fb.requestWithGraphPath('me/feed', null, "POST", showRequestResult);
    } else {
        Ti.API.debug('Failed authorization due to: ' + e.error);
    }
});

• 3.1.0
• 3.1.0
• 3.1.0

var listener = function() { Ti.API.info("Event listener called."); }
window.addEventListener('click', listener);

window.removeEventListener('click', listener);