Social Framework dans Xamarin.iOS

Social Framework fournit une API unifiée pour interagir avec les réseaux sociaux, notamment Twitter et Facebook, ainsi que SinaWeibo pour les utilisateurs en Chine.

L’utilisation de Social Framework permet aux applications d’interagir avec les réseaux sociaux à partir d’une seule API sans avoir à gérer l’authentification. Il inclut un contrôleur de vue fourni par le système pour composer des publications, ainsi qu’une abstraction qui permet de consommer l’API de chaque réseau social sur HTTP.

Connexion à Twitter

Paramètres du compte Twitter

Pour vous connecter à Twitter à l’aide de Social Framework, un compte doit être configuré dans les paramètres de l’appareil, comme indiqué ci-dessous :

Une fois qu’un compte a été entré et vérifié avec Twitter, toute application sur l’appareil qui utilise les classes Social Framework pour accéder à Twitter utilise ce compte.

Envoi de tweets

L’infrastructure sociale inclut un contrôleur appelé SLComposeViewController qui présente une vue fournie par le système pour la modification et l’envoi d’un tweet. La capture d’écran suivante montre un exemple de cette vue :

Pour utiliser un SLComposeViewController avec Twitter, une instance du contrôleur doit être créée en appelant la FromService méthode avec SLServiceType.Twitter comme indiqué ci-dessous :

var slComposer = SLComposeViewController.FromService (SLServiceType.Twitter);

Une fois la SLComposeViewController instance retournée, elle peut être utilisée pour présenter une interface utilisateur à publier sur Twitter. Toutefois, la première chose à faire est de case activée la disponibilité du réseau social, Twitter dans ce cas, en appelant IsAvailable:

if (SLComposeViewController.IsAvailable (SLServiceKind.Twitter)) {
  ...
}

SLComposeViewController n’envoie jamais de tweet directement sans interaction de l’utilisateur. Toutefois, il peut être initialisé avec les méthodes suivantes :

• SetInitialText : ajoute le texte initial à afficher dans le tweet.
• AddUrl : ajoute une URL au tweet.
• AddImage : ajoute une image au tweet.

Une fois initialisé, l’appel PresentVIewController affiche la vue créée par .SLComposeViewController L’utilisateur peut ensuite éventuellement modifier et envoyer le tweet, ou annuler son envoi. Dans les deux cas, le contrôleur doit être ignoré dans , CompletionHandleroù le résultat peut également être vérifié pour voir si le tweet a été envoyé ou annulé, comme indiqué ci-dessous :

slComposer.CompletionHandler += (result) => {
  InvokeOnMainThread (() => {
    DismissViewController (true, null);
    resultsTextView.Text = result.ToString ();
  });
};

Exemple de tweet

Le code suivant illustre l’utilisation de SLComposeViewController pour présenter une vue utilisée pour envoyer un tweet :

using System;
using Social;
using UIKit;

namespace SocialFrameworkDemo
{
    public partial class ViewController : UIViewController
    {
        #region Private Variables
        private SLComposeViewController _twitterComposer = SLComposeViewController.FromService (SLServiceType.Twitter);
        #endregion

        #region Computed Properties
        public bool isTwitterAvailable {
            get { return SLComposeViewController.IsAvailable (SLServiceKind.Twitter); }
        }

        public SLComposeViewController TwitterComposer {
            get { return _twitterComposer; }
        }
        #endregion

        #region Constructors
        protected ViewController (IntPtr handle) : base (handle)
        {

        }
        #endregion

        #region Override Methods
        public override void ViewWillAppear (bool animated)
        {
            base.ViewWillAppear (animated);

            // Update UI based on state
            SendTweet.Enabled = isTwitterAvailable;
        }
        #endregion

        #region Actions
        partial void SendTweet_TouchUpInside (UIButton sender)
        {
            // Set initial message
            TwitterComposer.SetInitialText ("Hello Twitter!");
            TwitterComposer.AddImage (UIImage.FromFile ("Icon.png"));
            TwitterComposer.CompletionHandler += (result) => {
                InvokeOnMainThread (() => {
                    DismissViewController (true, null);
                    Console.WriteLine ("Results: {0}", result);
                });
            };

            // Display controller
            PresentViewController (TwitterComposer, true, null);
        }
        #endregion
    }
}

Appel de l’API Twitter

Le cadre social inclut également la prise en charge de l’envoi de requêtes HTTP aux réseaux sociaux. Il encapsule la requête dans une SLRequest classe qui est utilisée pour cibler l’API du réseau social particulier.

Par exemple, le code suivant demande à Twitter d’obtenir le chronologie public (en développant le code donné ci-dessus) :

using Accounts;
...

#region Private Variables
private ACAccount _twitterAccount;
#endregion

#region Computed Properties
public ACAccount TwitterAccount {
    get { return _twitterAccount; }
}
#endregion

#region Override Methods
public override void ViewWillAppear (bool animated)
{
    base.ViewWillAppear (animated);

    // Update UI based on state
    SendTweet.Enabled = isTwitterAvailable;
    RequestTwitterTimeline.Enabled = false;

    // Initialize Twitter Account access
    var accountStore = new ACAccountStore ();
    var accountType = accountStore.FindAccountType (ACAccountType.Twitter);

    // Request access to Twitter account
    accountStore.RequestAccess (accountType, (granted, error) => {
        // Allowed by user?
        if (granted) {
            // Get account
            _twitterAccount = accountStore.Accounts [accountStore.Accounts.Length - 1];
            InvokeOnMainThread (() => {
                // Update UI
                RequestTwitterTimeline.Enabled = true;
            });
        }
    });
}
#endregion

#region Actions
partial void RequestTwitterTimeline_TouchUpInside (UIButton sender)
{
    // Initialize request
    var parameters = new NSDictionary ();
    var url = new NSUrl("https://api.twitter.com/1.1/statuses/user_timeline.json?count=10");
    var request = SLRequest.Create (SLServiceKind.Twitter, SLRequestMethod.Get, url, parameters);

    // Request data
    request.Account = TwitterAccount;
    request.PerformRequest ((data, response, error) => {
        // Was there an error?
        if (error == null) {
            // Was the request successful?
            if (response.StatusCode == 200) {
                // Yes, display it
                InvokeOnMainThread (() => {
                    Results.Text = data.ToString ();
                });
            } else {
                // No, display error
                InvokeOnMainThread (() => {
                    Results.Text = string.Format ("Error: {0}", response.StatusCode);
                });
            }
        } else {
            // No, display error
            InvokeOnMainThread (() => {
                Results.Text = string.Format ("Error: {0}", error);
            });
        }
    });
}
#endregion

Examinons ce code en détail. Tout d’abord, il obtient l’accès au Magasin de comptes et obtient le type d’un compte Twitter :

var accountStore = new ACAccountStore ();
var accountType = accountStore.FindAccountType (ACAccountType.Twitter);

Ensuite, il demande à l’utilisateur si votre application peut avoir accès à son compte Twitter et, si l’accès est accordé, le compte est chargé en mémoire et l’interface utilisateur est mise à jour :

// Request access to Twitter account
accountStore.RequestAccess (accountType, (granted, error) => {
    // Allowed by user?
    if (granted) {
        // Get account
        _twitterAccount = accountStore.Accounts [accountStore.Accounts.Length - 1];
        InvokeOnMainThread (() => {
            // Update UI
            RequestTwitterTimeline.Enabled = true;
        });
    }
});

Lorsque l’utilisateur demande les données chronologie (en appuyant sur un bouton dans l’interface utilisateur), l’application commence par former une demande d’accès aux données à partir de Twitter :

// Initialize request
var parameters = new NSDictionary ();
var url = new NSUrl("https://api.twitter.com/1.1/statuses/user_timeline.json?count=10");
var request = SLRequest.Create (SLServiceKind.Twitter, SLRequestMethod.Get, url, parameters);

Cet exemple limite les résultats retournés aux dix dernières entrées en incluant ?count=10 dans l’URL. Enfin, il joint la demande au compte Twitter (qui a été chargé ci-dessus) et effectue l’appel à Twitter pour récupérer les données :

// Request data
request.Account = TwitterAccount;
request.PerformRequest ((data, response, error) => {
    // Was there an error?
    if (error == null) {
        // Was the request successful?
        if (response.StatusCode == 200) {
            // Yes, display it
            InvokeOnMainThread (() => {
                Results.Text = data.ToString ();
            });
        } else {
            // No, display error
            InvokeOnMainThread (() => {
                Results.Text = string.Format ("Error: {0}", response.StatusCode);
            });
        }
    } else {
        // No, display error
        InvokeOnMainThread (() => {
            Results.Text = string.Format ("Error: {0}", error);
        });
    }
});

Si les données ont été correctement chargées, les données JSON brutes s’affichent (comme dans l’exemple de sortie ci-dessous) :

Dans une application réelle, les résultats JSON peuvent ensuite être analysés normalement et présentés à l’utilisateur. Pour plus d’informations sur l’analyse de JSON, consultez Introduction Web Services .

Connexion à Facebook

Paramètres du compte Facebook

La connexion à Facebook avec Social Framework est presque identique au processus utilisé pour Twitter ci-dessus. Un compte d’utilisateur Facebook doit être configuré dans les paramètres de l’appareil, comme indiqué ci-dessous :

Une fois configurée, toute application sur l’appareil qui utilise Social Framework utilise ce compte pour se connecter à Facebook.

Publication sur Facebook

Étant donné que Social Framework est une API unifiée conçue pour accéder à plusieurs réseaux sociaux, le code reste presque identique quel que soit le réseau social utilisé.

Par exemple, peut SLComposeViewController être utilisé exactement comme dans l’exemple Twitter présenté précédemment, la seule différence est de basculer vers les paramètres et options spécifiques à Facebook. Par exemple :

using System;
using Foundation;
using Social;
using UIKit;

namespace SocialFrameworkDemo
{
    public partial class ViewController : UIViewController
    {
        #region Private Variables
        private SLComposeViewController _facebookComposer = SLComposeViewController.FromService (SLServiceType.Facebook);
        #endregion

        #region Computed Properties
        public bool isFacebookAvailable {
            get { return SLComposeViewController.IsAvailable (SLServiceKind.Facebook); }
        }

        public SLComposeViewController FacebookComposer {
            get { return _facebookComposer; }
        }
        #endregion

        #region Constructors
        protected ViewController (IntPtr handle) : base (handle)
        {

        }
        #endregion

        #region Override Methods
        public override void ViewWillAppear (bool animated)
        {
            base.ViewWillAppear (animated);

            // Update UI based on state
            PostToFacebook.Enabled = isFacebookAvailable;
        }
        #endregion

        #region Actions
        partial void PostToFacebook_TouchUpInside (UIButton sender)
        {
            // Set initial message
            FacebookComposer.SetInitialText ("Hello Facebook!");
            FacebookComposer.AddImage (UIImage.FromFile ("Icon.png"));
            FacebookComposer.CompletionHandler += (result) => {
                InvokeOnMainThread (() => {
                    DismissViewController (true, null);
                    Console.WriteLine ("Results: {0}", result);
                });
            };

            // Display controller
            PresentViewController (FacebookComposer, true, null);
        }
        #endregion
    }
}

Lorsqu’il est utilisé avec Facebook, le SLComposeViewController affiche une vue qui semble presque identique à l’exemple Twitter, montrant Facebook comme titre dans ce cas :

Appel d’API Graph Facebook

À l’instar de l’exemple Twitter, l’objet social SLRequest Framework peut être utilisé avec l’API graphe de Facebook. Par exemple, le code suivant retourne des informations à partir de l’API graph sur le compte Xamarin (en développant le code donné ci-dessus) :

using Accounts;
...

#region Private Variables
private ACAccount _facebookAccount;
#endregion

#region Computed Properties
public ACAccount FacebookAccount {
    get { return _facebookAccount; }
}
#endregion

#region Override Methods
public override void ViewWillAppear (bool animated)
{
    base.ViewWillAppear (animated);

    // Update UI based on state
    PostToFacebook.Enabled = isFacebookAvailable;
    RequestFacebookTimeline.Enabled = false;

    // Initialize Facebook Account access
    var accountStore = new ACAccountStore ();
    var options = new AccountStoreOptions ();
    var options.FacebookAppId = ""; // Enter your specific Facebook App ID here
    accountType = accountStore.FindAccountType (ACAccountType.Facebook);

    // Request access to Facebook account
    accountStore.RequestAccess (accountType, options, (granted, error) => {
        // Allowed by user?
        if (granted) {
            // Get account
            _facebookAccount = accountStore.Accounts [accountStore.Accounts.Length - 1];
            InvokeOnMainThread (() => {
                // Update UI
                RequestFacebookTimeline.Enabled = true;
            });
        }
    });

}
#endregion

#region Actions
partial void RequestFacebookTimeline_TouchUpInside (UIButton sender)
{
    // Initialize request
    var parameters = new NSDictionary ();
    var url = new NSUrl ("https://graph.facebook.com/283148898401104");
    var request = SLRequest.Create (SLServiceKind.Facebook, SLRequestMethod.Get, url, parameters);

    // Request data
    request.Account = FacebookAccount;
    request.PerformRequest ((data, response, error) => {
        // Was there an error?
        if (error == null) {
            // Was the request successful?
            if (response.StatusCode == 200) {
                // Yes, display it
                InvokeOnMainThread (() => {
                    Results.Text = data.ToString ();
                });
            } else {
                // No, display error
                InvokeOnMainThread (() => {
                    Results.Text = string.Format ("Error: {0}", response.StatusCode);
                });
            }
        } else {
            // No, display error
            InvokeOnMainThread (() => {
                Results.Text = string.Format ("Error: {0}", error);
            });
        }
    });
}
#endregion

La seule différence réelle entre ce code et la version twitter présentée ci-dessus est l’exigence de Facebook d’obtenir un ID spécifique au développeur/à l’application (que vous pouvez générer à partir du portail des développeurs de Facebook) qui doit être défini en tant qu’option lors de la demande :

var options = new AccountStoreOptions ();
var options.FacebookAppId = ""; // Enter your specific Facebook App ID here
...

// Request access to Facebook account
accountStore.RequestAccess (accountType, options, (granted, error) => {
    ...
});

L’échec de la définition de cette option (ou l’utilisation d’une clé non valide) entraîne une erreur ou l’absence de données retournées.

Résumé

Cet article a montré comment utiliser le social framework pour interagir avec Twitter et Facebook. Il a montré où configurer les comptes pour chaque réseau social dans les paramètres de l’appareil. Il a également discuté de la façon d’utiliser pour SLComposeViewController présenter une vue unifiée pour la publication sur les réseaux sociaux. En outre, il a examiné la SLRequest classe utilisée pour appeler l’API de chaque réseau social.

Liens associés

• SocialFrameworkDemo (exemple)
• Présentation des services web