Struktura adaptera synchronizacji zakłada, że adapter synchronizacji przenosi dane między pamięcią urządzenia powiązane z kontem i pamięcią serwera, która wymaga logowania. Z tego powodu platforma wymaga udostępnienia w ramach synchronizacji komponentu zwanego uwierzytelnianiem przejściówkę. Łączy się on z kontami Androida i platformą uwierzytelniania, udostępnia standardowy interfejs do obsługi danych logowania użytkownika, takich jak dane logowania.
Nawet jeśli aplikacja nie korzysta z kont, nadal musisz udostępnić komponent uwierzytelniający.
Jeśli nie korzystasz z kont ani loginu do serwera, informacje są przetwarzane przez mechanizm uwierzytelniający
jest ignorowany, więc możesz podać komponent uwierzytelniający zawierający metodę stub
implementacji. Musisz też podać wartość Service, która
umożliwia platformie adaptera synchronizacji wywoływanie metod modułu uwierzytelniającego.
Z tej lekcji dowiesz się, jak zdefiniować wszystkie części mechanizmu uwierzytelniającego, które są niezbędne
spełniają wymagania platformy adaptera synchronizacji. Jeśli musisz podać
dla aplikacji uwierzytelniających, która obsługuje konta użytkowników, zapoznaj się z dokumentacją
AbstractAccountAuthenticator
Dodaj komponent uwierzytelniający pośrednika
Aby dodać do aplikacji komponent uwierzytelniający, utwórz klasę rozszerzoną
AbstractAccountAuthenticator, a następnie wyłącz wymagane metody,
przez zwrócenie null lub przez zgłoszenie wyjątku.
Ten fragment kodu zawiera przykładową klasę uwierzytelniającą „stub”:
Kotlin
/* * Implement AbstractAccountAuthenticator and stub out all * of its methods */ class Authenticator(context: Context) // Simple constructor : AbstractAccountAuthenticator(context) { // Editing properties is not supported override fun editProperties(r: AccountAuthenticatorResponse, s: String): Bundle { throw UnsupportedOperationException() } // Don't add additional accounts @Throws(NetworkErrorException::class) override fun addAccount( r: AccountAuthenticatorResponse, s: String, s2: String, strings: Array<String>, bundle: Bundle ): Bundle? = null // Ignore attempts to confirm credentials @Throws(NetworkErrorException::class) override fun confirmCredentials( r: AccountAuthenticatorResponse, account: Account, bundle: Bundle ): Bundle? = null // Getting an authentication token is not supported @Throws(NetworkErrorException::class) override fun getAuthToken( r: AccountAuthenticatorResponse, account: Account, s: String, bundle: Bundle ): Bundle { throw UnsupportedOperationException() } // Getting a label for the auth token is not supported override fun getAuthTokenLabel(s: String): String { throw UnsupportedOperationException() } // Updating user credentials is not supported @Throws(NetworkErrorException::class) override fun updateCredentials( r: AccountAuthenticatorResponse, account: Account, s: String, bundle: Bundle ): Bundle { throw UnsupportedOperationException() } // Checking features for the account is not supported @Throws(NetworkErrorException::class) override fun hasFeatures( r: AccountAuthenticatorResponse, account: Account, strings: Array<String> ): Bundle { throw UnsupportedOperationException() } }
Java
/* * Implement AbstractAccountAuthenticator and stub out all * of its methods */ public class Authenticator extends AbstractAccountAuthenticator { // Simple constructor public Authenticator(Context context) { super(context); } // Editing properties is not supported @Override public Bundle editProperties( AccountAuthenticatorResponse r, String s) { throw new UnsupportedOperationException(); } // Don't add additional accounts @Override public Bundle addAccount( AccountAuthenticatorResponse r, String s, String s2, String[] strings, Bundle bundle) throws NetworkErrorException { return null; } // Ignore attempts to confirm credentials @Override public Bundle confirmCredentials( AccountAuthenticatorResponse r, Account account, Bundle bundle) throws NetworkErrorException { return null; } // Getting an authentication token is not supported @Override public Bundle getAuthToken( AccountAuthenticatorResponse r, Account account, String s, Bundle bundle) throws NetworkErrorException { throw new UnsupportedOperationException(); } // Getting a label for the auth token is not supported @Override public String getAuthTokenLabel(String s) { throw new UnsupportedOperationException(); } // Updating user credentials is not supported @Override public Bundle updateCredentials( AccountAuthenticatorResponse r, Account account, String s, Bundle bundle) throws NetworkErrorException { throw new UnsupportedOperationException(); } // Checking features for the account is not supported @Override public Bundle hasFeatures( AccountAuthenticatorResponse r, Account account, String[] strings) throws NetworkErrorException { throw new UnsupportedOperationException(); } }
Powiąż mechanizm uwierzytelniający ze platformą
Aby platforma adaptera synchronizacji miała dostęp do uwierzytelniania, musisz utworzyć powiązanie Serwis. Ta usługa udostępnia obiekt powiązania Androida, który umożliwia korzystanie z platformy aby wywołać aplikację uwierzytelniającą i przekazać dane między tym modułem a platformą.
Ten fragment kodu pokazuje, jak określić granicę Service:
Kotlin
/** * A bound Service that instantiates the authenticator * when started. */ class AuthenticatorService : Service() { // Instance field that stores the authenticator object private lateinit var mAuthenticator: Authenticator override fun onCreate() { // Create a new authenticator object mAuthenticator = Authenticator(getApplicationContext()) } /* * When the system binds to this Service to make the RPC call * return the authenticator's IBinder. */ override fun onBind(intent: Intent?): IBinder = mAuthenticator.iBinder }
Java
/** * A bound Service that instantiates the authenticator * when started. */ public class AuthenticatorService extends Service { ... // Instance field that stores the authenticator object private Authenticator mAuthenticator; @Override public void onCreate() { // Create a new authenticator object mAuthenticator = new Authenticator(getApplicationContext()); } /* * When the system binds to this Service to make the RPC call * return the authenticator's IBinder. */ @Override public IBinder onBind(Intent intent) { return mAuthenticator.getIBinder(); } }
Dodaj plik metadanych uwierzytelniania
Aby podłączyć komponent uwierzytelniający do adaptera synchronizacji i platform konta, musisz:
wraz z metadanymi opisującymi komponent. Te metadane deklarują
typ konta utworzonego dla adaptera synchronizacji i deklaruje elementy interfejsu użytkownika
którą system wyświetla,
jeśli chcesz, aby dany rodzaj konta był widoczny dla użytkownika. Zadeklaruj to
w pliku XML przechowywanym w katalogu /res/xml/ w projekcie aplikacji.
Plik może mieć dowolną nazwę, ale zwykle nazywa się on authenticator.xml.
Ten plik XML zawiera jeden element <account-authenticator>, który
ma następujące atrybuty:
-
android:accountType -
Platforma adaptera synchronizacji wymaga, aby każdy adapter synchronizacji miał typ konta w postaci
od nazwy domeny. Platforma wykorzystuje typ konta jako część
do ich wewnętrznej identyfikacji. W przypadku serwerów wymagających logowania podaj typ konta wraz ze znakiem
dane konta użytkownika są wysyłane na serwer w ramach danych logowania.
Jeśli Twój serwer nie wymaga logowania, musisz podać rodzaj konta. W przypadku atrybutu użyj nazwy domeny, nad którą masz kontrolę. Platforma używa jej do zarządzania adapter synchronizacji, wartość nie jest wysyłana do serwera.
-
android:icon -
Wskaźnik elementu elementu rysowalnego
zasób zawierający ikonę. Jeśli zapewnisz widoczność adaptera synchronizacji przez określenie parametru
atrybut
android:userVisible="true"wres/xml/syncadapter.xml, musisz podać tę ikonę. Jest on widoczny w sekcji Konta w aplikacji Ustawienia. -
android:smallIcon -
Wskaźnik elementu elementu rysowalnego
z niewielką wersją ikony. Tego zasobu można użyć zamiast
android:iconw sekcji Konta w systemowej aplikacji Ustawienia, w zależności od rozmiaru ekranu. -
android:label -
Możliwe do zlokalizowania ciąg znaków określający typ konta dla użytkowników. Jeśli skorzystasz z adaptera synchronizacji
widoczne przez określenie atrybutu
android:userVisible="true"wres/xml/syncadapter.xml, wpisz ten ciąg. Wyświetla się w Konta w systemowej aplikacji Ustawienia, obok ikony zdefiniowanej dla uwierzytelnianie.
Poniższy fragment kodu zawiera plik XML utworzonego wcześniej modułu uwierzytelniającego:
<?xml version="1.0" encoding="utf-8"?> <account-authenticator xmlns:android="http://schemas.android.com/apk/res/android" android:accountType="example.com" android:icon="@drawable/ic_launcher" android:smallIcon="@drawable/ic_launcher" android:label="@string/app_name"/>
Zadeklaruj uwierzytelnianie w pliku manifestu
W poprzednim kroku utworzyłeś(-aś) powiązanie Service, które łączy uwierzytelnianie
do platformy adaptera synchronizacji. Aby zidentyfikować tę usługę w systemie, zadeklaruj ją w aplikacji
pliku manifestu, dodając
<service>
jako elementu potomnego argumentu
<application>:
<service android:name="com.example.android.syncadapter.AuthenticatorService"> <intent-filter> <action android:name="android.accounts.AccountAuthenticator"/> </intent-filter> <meta-data android:name="android.accounts.AccountAuthenticator" android:resource="@xml/authenticator" /> </service>
<intent-filter>
konfiguruje filtr wywoływany przez działanie intencji
android.accounts.AccountAuthenticator, które są wysyłane przez system w celu uruchomienia
uwierzytelnianie. Po aktywowaniu filtra system rozpoczyna działanie AuthenticatorService,
zakres Service podany w celu opakowania uwierzytelniającego.
<meta-data>
deklaruje metadane modułu uwierzytelniającego.
android:name
łączy metadane ze platformą uwierzytelniania.
android:resource
określa nazwę utworzonego wcześniej pliku metadanych uwierzytelniania.
Oprócz uwierzytelniania adapter synchronizacji wymaga też dostawcy treści. Jeśli aplikacja nie korzysta już z dostawcy treści, przejdź do następnej lekcji, aby dowiedzieć się, jak utworzyć treść skróconą. usługodawcy; W przeciwnym razie przejdź do lekcji Tworzenie adaptera synchronizacji.