AbstractThreadedSyncAdapter Classe

Définition

Espace de noms:: Android.Content

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation.

[Android.Runtime.Register("android/content/AbstractThreadedSyncAdapter", DoNotGenerateAcw=true)]
public abstract class AbstractThreadedSyncAdapter : Java.Lang.Object

[<Android.Runtime.Register("android/content/AbstractThreadedSyncAdapter", DoNotGenerateAcw=true)>]
type AbstractThreadedSyncAdapter = class
    inherit Object

Héritage: Object

Object
AbstractThreadedSyncAdapter

Attributs: RegisterAttribute

Remarques

Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. Si une opération de synchronisation est déjà en cours lors de la réception d’une demande de synchronisation, une erreur est retournée à la nouvelle demande et la demande existante est autorisée à continuer. Toutefois, s’il n’y a pas de synchronisation en cours, un thread sera généré et #onPerformSync sera appelé sur ce thread.

Les synchronisations peuvent être annulées à tout moment par l’infrastructure. Par exemple, une synchronisation qui n’a pas été initiée par l’utilisateur et dure plus de 10 minutes est considérée comme expirée et annulée. De même, le framework tente de déterminer si une carte progresse ou non en surveillant son activité réseau au cours d’une minute. Si le trafic réseau sur cette fenêtre est assez proche de zéro, la synchronisation est annulée. Vous pouvez également demander l’annulation de la synchronisation via ContentResolver#cancelSync(Account, String) ou ContentResolver#cancelSync(SyncRequest).

Une synchronisation est annulée en émettant un Thread#interrupt() sur le thread de synchronisation. <fort>soit votre code doit #onPerformSync(Account, Bundle, String, ContentProviderClient, SyncResult) être vérifiéThread#interrupted(), soit vous devez remplacer l’un de#onSyncCanceled()<#onSyncCanceled(Thread)/ /strong> (selon que votre adaptateur prend en charge la synchronisation de plusieurs comptes en parallèle). Si votre adaptateur ne respecte pas l’annulation émise par l’infrastructure, vous risquez de tuer l’ensemble du processus de votre application.

Pour qu’il s’agisse d’un adaptateur de synchronisation, il faut étendre cette classe, fournir des implémentations pour les méthodes abstraites et écrire un service qui retourne le résultat dans #getSyncAdapterBinder() le service lorsqu’il android.app.Service#onBind(android.content.Intent) est appelé avec une intention avec une action android.content.SyncAdapter. Ce service doit spécifier le filtre d’intention et les balises de métadonnées suivants dans son fichier AndroidManifest.xml

&lt;intent-filter&gt;
                &lt;action android:name="android.content.SyncAdapter" /&gt;
              &lt;/intent-filter&gt;
              &lt;meta-data android:name="android.content.SyncAdapter"
                        android:resource="@xml/syncadapter" /&gt;

L’attribut android:resource doit pointer vers une ressource qui ressemble à ceci :

&lt;sync-adapter xmlns:android="http://schemas.android.com/apk/res/android"
               android:contentAuthority="authority"
               android:accountType="accountType"
               android:userVisible="true|false"
               android:supportsUploading="true|false"
               android:allowParallelSyncs="true|false"
               android:isAlwaysSyncable="true|false"
               android:syncAdapterSettingsAction="ACTION_OF_SETTINGS_ACTIVITY"
            /&gt;

<ul><li>Les android:contentAuthority attributs et android:accountType les attributs indiquent quelle autorité de contenu et pour quels types de compte cette carte de synchronisation sert. <li est>android:userVisible défini par défaut sur true et contrôle si cet adaptateur de synchronisation s’affiche ou non dans l’écran Paramètres de synchronisation. <li>android:supportsUploading defaults to true et si true une synchronisation de chargement uniquement est demandée pour tous les syncadapters associés à une autorité chaque fois que le fournisseur de contenu de cette autorité effectue une ContentResolver#notifyChange(android.net.Uri, android.database.ContentObserver, boolean) opération avec syncToNetwork défini sur true. <li>android:allowParallelSyncs par défaut a la valeur false et, si true indique que l’adaptateur de synchronisation peut gérer les synchronisations pour plusieurs comptes en même temps. Sinon, SyncManager attend que l’adaptateur de synchronisation ne soit pas utilisé avant de demander qu’il synchronise les données d’un compte. <li>android:isAlwaysSyncable est défini par défaut sur false et si true indique à SyncManager d’initialiser l’état isSyncable sur 1 pour cet adaptateur de synchronisation pour chaque compte ajouté. <li>android:syncAdapterSettingsAction est défini par défaut sur Null et, s’il est fourni, il spécifie une action Intention d’une activité qui peut être utilisée pour ajuster les paramètres de synchronisation de l’adaptateur de synchronisation. L’activité doit se trouver dans le même package que l’adaptateur de synchronisation. </ul>

Java documentation pour android.content.AbstractThreadedSyncAdapter.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.

Constructeurs

Nom	Description
AbstractThreadedSyncAdapter(Context, Boolean, Boolean)	Crée un `AbstractThreadedSyncAdapter`.
AbstractThreadedSyncAdapter(Context, Boolean)	Crée un `AbstractThreadedSyncAdapter`.
AbstractThreadedSyncAdapter(IntPtr, JniHandleOwnership)	Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.

Champs

Nom	Description
LogSyncDetails	Obsolète. Balise du journal des événements du noyau.

Propriétés

Nom	Description
Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
Context
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
JniPeerMembers	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation.
PeerReference	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
SyncAdapterBinder
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.

Méthodes

Nom	Description
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
Dispose()	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
Dispose(Boolean)	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
GetHashCode()	Retourne une valeur de code de hachage pour l’objet. (Hérité de Object)
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
OnPerformSync(Account, Bundle, String, ContentProviderClient, SyncResult)	Effectuez une synchronisation pour ce compte.
OnSecurityException(Account, Bundle, String, SyncResult)	Signalez qu’une exception de sécurité s’est produit lors de l’ouverture du fournisseur de contenu avant l’appel `#onPerformSync`.
OnSyncCanceled()	Indique qu’une opération de synchronisation a été annulée.
OnSyncCanceled(Thread)	Indique qu’une opération de synchronisation a été annulée.
OnUnsyncableAccount()	Permet de différer la synchronisation jusqu’à ce que tous les comptes soient correctement configurés.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
ToArray<T>()	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
ToString()	Retourne une représentation sous forme de chaîne de l’objet. (Hérité de Object)
UnregisterFromRuntime()	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)

Implémentations d’interfaces explicites

Nom	Description
IJavaPeerable.Disposed()	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
IJavaPeerable.Finalized()	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation. (Hérité de Object)

Méthodes d’extension

Nom	Description
GetJniTypeName(IJavaPeerable)	Obtient le nom JNI du type de l’instance `self`.
JavaAs<TResult>(IJavaPeerable)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.
JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Implémentation abstraite d’un SyncAdapter qui génère un thread pour appeler une opération de synchronisation.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.

S’applique à