ContentCaptureManager Classe

Definição

[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

Herança

Object

Object

ContentCaptureManager

Atributos

RegisterAttribute

Comentários

Fornece maneiras adicionais de os aplicativos se integrarem ao subsistema de captura de conteúdo.

A captura de conteúdo fornece captura contínua e em tempo real da atividade do aplicativo, exibição e eventos para um serviço de inteligência fornecido pelo sistema Android. Em seguida, o serviço de inteligência usa essas informações para mediar e acelerar o percurso do usuário por diferentes aplicativos. Por exemplo, quando o usuário recebe um endereço de restaurante em um aplicativo de chat e alterna para um aplicativo de mapa para procurar esse restaurante, o serviço de inteligência pode oferecer uma caixa de diálogo de preenchimento automático para permitir que o usuário selecione automaticamente seu endereço.

A captura de conteúdo foi projetada com duas grandes preocupações em mente: privacidade e desempenho.

<ul><li><b>Privacidade:</b> o serviço de inteligência é um componente confiável fornecido pelo fabricante do dispositivo e que não pode ser alterado pelo usuário (embora o usuário possa desabilitar globalmente a captura de conteúdo usando o aplicativo Configurações do Android). Esse serviço só pode usar os dados para o aprendizado de máquina no dispositivo, que é imposto tanto pelo isolamento do processo quanto pelos requisitos de CDD. <li><b>Desempenho:</b> a captura de conteúdo é altamente otimizada para minimizar seu impacto na integridade geral do sistema de dispositivos e no aplicativo. Por exemplo, ele só está habilitado em aplicativos (ou até mesmo em atividades específicas de um aplicativo) que foram explicitamente permitidos pelo serviço de inteligência e armazena os eventos em buffer para que eles sejam enviados em um lote para o serviço (consulte #isContentCaptureEnabled() outros casos em que ele está desabilitado). </ul>

Na verdade, antes de usar esse gerenciador, o desenvolvedor do aplicativo deve verificar se ele está disponível. Exemplo:

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

Os desenvolvedores de aplicativos geralmente não precisam interagir explicitamente com a captura de conteúdo, exceto quando o aplicativo:

<ul><li>Pode definir um contextual android.content.LocusId para identificar o estado exclusivo (como uma conversa entre dois usuários de chat). <li>Pode ter várias hierarquias de exibição com significado contextual diferente (por exemplo, um aplicativo de navegador com várias guias, cada uma representando uma URL diferente). <li>Contém exibições personalizadas (que estendem a exibição diretamente e não são fornecidas pelo SDK do Android padrão. <li>Contém exibições que fornecem sua própria hierarquia virtual (como um navegador da Web que renderiza os elementos HTML usando uma Tela). </ul>

O principal ponto de integração com a captura de conteúdo é o ContentCaptureSession. Uma sessão "principal" é criada automaticamente pelo Sistema Android quando a captura de conteúdo é habilitada para a atividade e é usada pelos modos de exibição padrão do Android para notificar o serviço de captura de conteúdo de eventos, como exibições sendo adicionadas, exibições foram removidas e texto alterado pela entrada do usuário. A sessão poderia ter um ContentCaptureContext para fornecer mais informações contextuais sobre ela, como o locus associado à hierarquia de exibição (consulte android.content.LocusId mais informações sobre locus). Por padrão, a sessão principal não tem um ContentCaptureContext, mas você pode alterá-la após sua criação. Exemplo:

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

Se sua atividade contiver hierarquias de exibição com um significado contextual diferente, você deverá criar sessões filho para cada raiz da hierarquia de exibição. Por exemplo, se sua atividade for um navegador, você poderá usar a sessão principal para a URL principal que está sendo renderizada, em seguida, sessões filho para cada 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>

Se sua atividade tiver exibições personalizadas (ou seja, exibições que se estendem View diretamente e fornecem apenas uma exibição lógica, não uma hierarquia de árvore virtual) e fornece conteúdo relevante para a captura de conteúdo (a partir de android.os.Build.VERSION_CODES#Q Android Q, o único conteúdo relevante é texto), sua implementação de exibição deve:

<ul><li>Defina-o como importante para a captura de conteúdo. <li>Fill ViewStructure usado para captura de conteúdo. <li>Notificar quando ContentCaptureSession o texto é alterado pela entrada do usuário. </ul>

Aqui está um exemplo dos métodos relevantes para uma exibição EditTextsemelhante:

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

Se o modo de exibição fornecer sua própria hierarquia virtual (por exemplo, se for um navegador que desenha o HTML usando Canvas ou bibliotecas nativas em um processo de renderização diferente), o modo de exibição também será responsável por notificar a sessão quando os elementos virtuais aparecerem e desaparecerem . View#onProvideContentCaptureStructure(ViewStructure, int) Confira mais informações.

Java documentação para android.view.contentcapture.ContentCaptureManager.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.