ContentCaptureManager Classe

Définition

[Android.Runtime.Register("android/view/contentcapture/ContentCaptureManager", ApiSince=29, DoNotGenerateAcw=true)]
public sealed class ContentCaptureManager : Java.Lang.Object

[<Android.Runtime.Register("android/view/contentcapture/ContentCaptureManager", ApiSince=29, DoNotGenerateAcw=true)>]
type ContentCaptureManager = class
    inherit Object

Héritage

Object

JavaObject

Object

ContentCaptureManager

Attributs

RegisterAttribute

Remarques

Fournit des moyens supplémentaires pour que les applications s’intègrent au sous-système de capture de contenu.

La capture de contenu fournit une capture en temps réel et continue de l’activité des applications, de l’affichage et des événements dans un service d’intelligence fourni par le système Android. Le service d’intelligence utilise ensuite ces informations pour médiater et accélérer le parcours utilisateur via différentes applications. Par exemple, lorsque l’utilisateur reçoit une adresse de restaurant dans une application de conversation et passe à une application cartographique pour rechercher ce restaurant, le service d’intelligence peut proposer une boîte de dialogue de remplissage automatique pour permettre à l’utilisateur de sélectionner automatiquement son adresse.

La capture de contenu a été conçue avec deux préoccupations majeures à l’esprit : la confidentialité et les performances.

<ul><li><b>Privacy :</b> le service intelligence est un composant approuvé fourni par le fabricant de l’appareil et qui ne peut pas être modifié par l’utilisateur (bien que l’utilisateur puisse désactiver la capture de contenu à l’aide de l’application Paramètres Android). Ce service peut uniquement utiliser les données pour le Machine Learning in-device, qui est appliqué à la fois par l’isolation des processus et les exigences CDD. <li><b>Performance :</b> la capture de contenu est hautement optimisée pour réduire son impact dans les jankiness d’application et l’intégrité globale du système d’appareil. Par exemple, sa seule activation sur les applications (ou même les activités spécifiques d’une application) qui ont été explicitement autorisées par le service d’intelligence, et met en mémoire tampon les événements afin qu’ils soient envoyés dans un lot au service (voir #isContentCaptureEnabled() pour d’autres cas lorsque son désactivé). </ul>

En fait, avant d’utiliser ce gestionnaire, le développeur d’applications doit vérifier s’il est disponible. Exemple :

<code>
             ContentCaptureManager mgr = context.getSystemService(ContentCaptureManager.class);
             if (mgr != null && mgr.isContentCaptureEnabled()) {
               // ...
             }
</code>

Les développeurs d’applications n’ont généralement pas besoin d’interagir explicitement avec la capture de contenu, sauf lorsque l’application :

<ul><li>Peut définir un contexte android.content.LocusId pour identifier un état unique (par exemple, une conversation entre 2 utilisateurs de conversation). <li>Peut avoir plusieurs hiérarchies d’affichage avec une signification contextuelle différente (par exemple, une application de navigateur avec plusieurs onglets, chacune représentant une URL différente). <li>Contient des vues personnalisées (qui étendent directement l’affichage et ne sont pas fournies par le Kit de développement logiciel (SDK) Android standard. <li>Contient des vues qui fournissent leur propre hiérarchie virtuelle (comme un navigateur web qui affiche les éléments HTML à l’aide d’un canevas). </ul>

Le point d’intégration principal avec la capture de contenu est le ContentCaptureSession. Une session « principale » est automatiquement créée par le système Android lorsque la capture de contenu est activée pour l’activité et son utilisation par les vues Android standard pour notifier le service de capture de contenu des événements tels que les vues ajoutées, les vues ont été supprimées et le texte modifié par l’entrée utilisateur. La session peut avoir un ContentCaptureContext pour fournir des informations plus contextuelles sur celle-ci, telles que le locus associé à la hiérarchie d’affichage (voir android.content.LocusId pour plus d’informations sur le locus). Par défaut, la session principale n’a pas de ContentCaptureContextsession principale, mais vous pouvez la modifier après sa création. Exemple :

<code>
            protected void onCreate(Bundle savedInstanceState) {
              // Initialize view structure
              ContentCaptureSession session = rootView.getContentCaptureSession();
              if (session != null) {
                session.setContentCaptureContext(ContentCaptureContext.forLocusId("chat_UserA_UserB"));
              }
            }
</code>

Si votre activité contient des hiérarchies d’affichage avec une signification contextuelle différente, vous devez créer des sessions enfants pour chaque racine de hiérarchie d’affichage. Par exemple, si votre activité est un navigateur, vous pouvez utiliser la session principale pour l’URL principale affichée, puis les sessions enfants pour chacune d’elles IFRAME:

<code>
            ContentCaptureSession mMainSession;

            protected void onCreate(Bundle savedInstanceState) {
               // Initialize view structure...
               mMainSession = rootView.getContentCaptureSession();
               if (mMainSession != null) {
                 mMainSession.setContentCaptureContext(
                     ContentCaptureContext.forLocusId("https://example.com"));
               }
            }

            private void loadIFrame(View iframeRootView, String url) {
              if (mMainSession != null) {
                 ContentCaptureSession iFrameSession = mMainSession.newChild(
                     ContentCaptureContext.forLocusId(url));
                 }
                 iframeRootView.setContentCaptureSession(iFrameSession);
              }
              // Load iframe...
            }
</code>

Si votre activité a des vues personnalisées (c’est-à-dire des vues qui s’étendent View directement et fournissent une seule vue logique, et non une hiéarchisation d’arborescence virtuelle) et fournit du contenu pertinent pour la capture de contenu (à partir de android.os.Build.VERSION_CODES#Q Android Q, le seul contenu pertinent est du texte), votre implémentation de vue doit :

<ul><li>Définissez-le comme important pour la capture de contenu. <li>Fill ViewStructure utilisé pour la capture de contenu. <li>Notify the ContentCaptureSession when the text is change by user input. </ul>

Voici un exemple de méthodes pertinentes pour une EditTextvue semblable à celle-ci :

<code>
            public class MyEditText extends View {

            public MyEditText(...) {
              if (getImportantForContentCapture() == IMPORTANT_FOR_CONTENT_CAPTURE_AUTO) {
                setImportantForContentCapture(IMPORTANT_FOR_CONTENT_CAPTURE_YES);
              }
            }

            public void onProvideContentCaptureStructure(@NonNull ViewStructure structure, int flags) {
              super.onProvideContentCaptureStructure(structure, flags);

              structure.setText(getText(), getSelectionStart(), getSelectionEnd());
              structure.setHint(getHint());
              structure.setInputType(getInputType());
              // set other properties like setTextIdEntry(), setTextLines(), setTextStyle(),
              // setMinTextEms(), setMaxTextEms(), setMaxTextLength()
            }

            private void onTextChanged() {
              if (isLaidOut() && isImportantForContentCapture() && isTextEditable()) {
                ContentCaptureManager mgr = mContext.getSystemService(ContentCaptureManager.class);
                if (cm != null && cm.isContentCaptureEnabled()) {
                   ContentCaptureSession session = getContentCaptureSession();
                   if (session != null) {
                     session.notifyViewTextChanged(getAutofillId(), getText());
                   }
              }
            }
</code>

Si votre vue fournit sa propre hiérarchie virtuelle (par exemple, s’il s’agit d’un navigateur qui dessine le code HTML à l’aide Canvas ou les bibliothèques natives dans un autre processus de rendu), l’affichage est également chargé d’avertir la session lorsque les éléments virtuels apparaissent et disparaissent . Pour plus d’informations, voir View#onProvideContentCaptureStructure(ViewStructure, int) pour plus d’informations.

Java documentation pour android.view.contentcapture.ContentCaptureManager.

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.