Platforma Social Framework na platformie Xamarin.iOS

  • Artykuł

Struktura społecznościowa udostępnia ujednolicony interfejs API do interakcji z sieciami społecznościowymi, w tym Twitter i Facebook, a także SinaWeibo dla użytkowników w Chinach.

Korzystanie z platformy Social Framework umożliwia aplikacjom interakcję z sieciami społecznościowymi z jednego interfejsu API bez konieczności zarządzania uwierzytelnianiem. Zawiera on system udostępniony kontroler widoku do tworzenia wpisów, a także abstrakcji, która umożliwia korzystanie z interfejsu API każdej sieci społecznościowej za pośrednictwem protokołu HTTP.

Połączenie do usługi Twitter

Ustawienia konta w usłudze Twitter

Aby nawiązać połączenie z usługą Twitter przy użyciu platformy Social Framework, należy skonfigurować konto w ustawieniach urządzenia, jak pokazano poniżej:

Twitter Account Settings

Po wprowadzeniu i zweryfikowaniu konta w usłudze Twitter każda aplikacja na urządzeniu używająca klas Programu Social Framework do uzyskiwania dostępu do usługi Twitter będzie używać tego konta.

Wysyłanie tweetów

Struktura społecznościowa zawiera kontroler o nazwie SLComposeViewController , który przedstawia system udostępniony widok do edycji i wysyłania tweetu. Poniższy zrzut ekranu przedstawia przykład tego widoku:

This screenshot shows an example of the SLComposeViewController

Aby można było używać elementu SLComposeViewController z usługą Twitter, należy utworzyć wystąpienie kontrolera, wywołując metodę FromService przy SLServiceType.Twitter użyciu metody , jak pokazano poniżej:

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

SLComposeViewController Po powrocie wystąpienia można go użyć do prezentowania interfejsu użytkownika do publikowania w usłudze Twitter. Jednak pierwszą rzeczą do zrobienia jest sprawdzenie dostępności sieci społecznościowej, Twitter w tym przypadku, wywołując polecenie IsAvailable:

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

SLComposeViewController nigdy nie wysyła tweetu bezpośrednio bez interakcji użytkownika. Można go jednak zainicjować przy użyciu następujących metod:

  • SetInitialText — dodaje początkowy tekst do pokazania w tweecie.
  • AddUrl — dodaje adres URL do tweetu.
  • AddImage — dodaje obraz do tweetu.

Po zainicjowaniu wywołanie PresentVIewController powoduje wyświetlenie widoku utworzonego SLComposeViewControllerprzez element . Użytkownik może następnie opcjonalnie edytować i wysyłać tweet lub anulować jego wysyłanie. W obu przypadkach kontroler powinien zostać odrzucony w CompletionHandlerobiekcie , gdzie można również sprawdzić, czy tweet został wysłany lub anulowany, jak pokazano poniżej:

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

Przykład tweetu

Poniższy kod demonstruje użycie elementu , SLComposeViewController aby przedstawić widok używany do wysyłania tweetu:

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
    }
}

Wywoływanie interfejsu API usługi Twitter

Struktura społecznościowa obejmuje również obsługę podejmowania żądań HTTP do sieci społecznościowych. Hermetyzuje żądanie w SLRequest klasie, która jest używana do kierowania do interfejsu API określonej sieci społecznościowej.

Na przykład poniższy kod wysyła żądanie do usługi Twitter, aby uzyskać publiczną oś czasu (rozwijając kod podany powyżej):

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

Przyjrzyjmy się szczegółowo temu kodowi. Najpierw uzyskuje dostęp do Sklepu kont i pobiera typ konta w serwisie Twitter:

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

Następnie zostanie wyświetlony monit o to, czy aplikacja może mieć dostęp do swojego konta w serwisie Twitter, a jeśli dostęp zostanie udzielony, konto zostanie załadowane do pamięci i zaktualizowany interfejs użytkownika:

// 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;
        });
    }
});

Gdy użytkownik żąda danych osi czasu (naciskając przycisk w interfejsie użytkownika), aplikacja najpierw tworzy żądanie dostępu do danych z serwisu 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);

W tym przykładzie zwracane wyniki są ograniczane do ostatnich dziesięciu wpisów przez uwzględnienie ?count=10 ich w adresie URL. Na koniec dołącza żądanie do konta usługi Twitter (załadowane powyżej) i wykonuje wywołanie usługi Twitter w celu pobrania danych:

// 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);
        });
    }
});

Jeśli dane zostały pomyślnie załadowane, zostaną wyświetlone nieprzetworzone dane JSON (jak w przykładowych danych wyjściowych poniżej):

An example of the raw JSON data display

W rzeczywistej aplikacji wyniki JSON mogą być analizowane normalnie, a wyniki prezentowane użytkownikowi. Aby uzyskać informacje na temat analizowania kodu JSON, zobacz Wprowadzenie usług sieci Web.

Połączenie do Serwisu Facebook

Ustawienia konta w serwisie Facebook

Połączenie do Facebooka z Social Framework jest prawie identyczny z procesem używanym w serwisie Twitter pokazanym powyżej. Konto użytkownika serwisu Facebook musi być skonfigurowane w ustawieniach urządzenia, jak pokazano poniżej:

Facebook Account Settings

Po skonfigurowaniu każda aplikacja na urządzeniu korzystająca z programu Social Framework będzie używać tego konta do łączenia się z serwisem Facebook.

Publikowanie na Facebooku

Ponieważ platforma Social Framework to ujednolicony interfejs API przeznaczony do uzyskiwania dostępu do wielu sieci społecznościowych, kod pozostaje prawie identyczny niezależnie od używanej sieci społecznościowej.

Na przykład można go użyć dokładnie tak, jak w pokazanym wcześniej przykładzie SLComposeViewController twittera, a jedyną inną opcją jest przełączenie do ustawień i opcji specyficznych dla serwisu Facebook. Na przykład:

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
    }
}

W przypadku użycia z Serwisem Facebook SLComposeViewController wyświetla widok, który wygląda prawie identycznie z przykładem twittera, pokazujący Facebook jako tytuł w tym przypadku:

The SLComposeViewController display

Wywoływanie interfejsu API programu Facebook Graph

Podobnie jak w przykładzie usługi Twitter, obiekt programu Social Framework SLRequest może być używany z interfejsem API grafu serwisu Facebook. Na przykład poniższy kod zwraca informacje z interfejsu API grafu o koncie platformy Xamarin (rozwijając kod podany powyżej):

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

Jedyną rzeczywistą różnicą między tym kodem a przedstawioną powyżej wersją usługi Twitter jest wymaganie, aby użytkownik Facebooka mógł uzyskać identyfikator specyficzny dla deweloperów/aplikacji (który można wygenerować z portalu deweloperów serwisu Facebook), który należy ustawić jako opcję podczas składania żądania:

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) => {
    ...
});

Nie można ustawić tej opcji (lub użycie nieprawidłowego klucza) spowoduje zwrócenie błędu lub braku danych.

Podsumowanie

W tym artykule pokazano, jak korzystać z platformy Social Framework do interakcji z usługami Twitter i Facebook. Pokazano, gdzie skonfigurować konta dla każdej sieci społecznościowej w ustawieniach urządzenia. Omówiono również sposób używania elementu SLComposeViewController do prezentowania ujednoliconego widoku publikowania w sieciach społecznościowych. Ponadto przeanalizowała klasę SLRequest używaną do wywoływania interfejsu API każdej sieci społecznościowej.