AutofillService Classe

Definizione

Spazio dei nomi:: Android.Service.Autofill

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Un AutofillService è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.

[Android.Runtime.Register("android/service/autofill/AutofillService", ApiSince=26, DoNotGenerateAcw=true)]
public abstract class AutofillService : Android.App.Service

[<Android.Runtime.Register("android/service/autofill/AutofillService", ApiSince=26, DoNotGenerateAcw=true)>]
type AutofillService = class
    inherit Service

Ereditarietà: Object

JavaObject

Object

Context

ContextWrapper

Service
AutofillService

Attributi: RegisterAttribute

Commenti

Un AutofillService oggetto è associato al sistema Android solo a scopo di riempimento automatico se: <ol><li>Richiede l'autorizzazione android.permission.BIND_AUTOFILL_SERVICE nel relativo manifesto. <li>L'utente lo abilita in modo esplicito usando Impostazioni Android (la Settings#ACTION_REQUEST_SET_AUTOFILL_SERVICE finalità può essere usata per avviare tale schermata Impostazioni). </ol>

"BasicUsage"><h3>Basic usage</h3>

Il processo di riempimento automatico di base è definito dal flusso di lavoro seguente: ol li User focus an editable .The basic autofill process is defined by the workflow below: <ol><li>User focus an editable View. <li>View chiama AutofillManager#notifyViewEntered(android.view.View). <li>A ViewStructure che rappresenta tutte le visualizzazioni sullo schermo viene creato. <li>Il sistema Android si associa al servizio e chiama #onConnected(). <li>Il servizio riceve la struttura di visualizzazione tramite .#onFillRequest(FillRequest, CancellationSignal, FillCallback) <li>Il servizio risponde tramite FillCallback#onSuccess(FillResponse). <li>Il sistema Android chiama #onDisconnected() e annulla l'associazione AutofillServiceda . <li>Il sistema Android visualizza un'interfaccia utente di riempimento automatico con le opzioni inviate dal servizio. <li>L'utente sceglie un'opzione. <li>Le visualizzazioni appropriate sono riempite automaticamente. </ol>

Questo flusso di lavoro è stato progettato per ridurre al minimo l'ora in cui il sistema Android è associato al servizio; per ogni chiamata, viene associato al servizio, attende la risposta e annulla immediatamente l'associazione. Inoltre, queste chiamate sono considerate senza stato: se il servizio deve mantenere lo stato tra le chiamate, deve eseguire la propria gestione dello stato (tenendo presente che il processo del servizio potrebbe essere ucciso dal sistema Android quando non è associato; ad esempio, se il dispositivo è in esecuzione in memoria insufficiente).

In genere, ol #onFillRequest(FillRequest, CancellationSignal, FillCallback)<><li>Analizza la struttura di visualizzazione alla ricerca di visualizzazioni riempibili automaticamente, ad esempio usando .android.app.assist.AssistStructure.ViewNode#getAutofillHints() <li>Corrisponde alle visualizzazioni riempibili automaticamente con i dati dell'utente. <li>Creare un Dataset oggetto per ogni set di dati dell'utente che corrispondono a tali campi. <li>Riempire i set di dati con i valori e i set di dati appropriatiAutofillIdAutofillValue. <li>Aggiungere i set di dati all'oggetto FillResponse passato a FillCallback#onSuccess(FillResponse). </ol>

Ad esempio, per una schermata di accesso con visualizzazioni nome utente e password in cui l'utente ha un solo account nel servizio, la risposta potrebbe essere:

new FillResponse.Builder()
                .addDataset(new Dataset.Builder()
                    .setValue(id1, AutofillValue.forText("homer"), createPresentation("homer"))
                    .setValue(id2, AutofillValue.forText("D'OH!"), createPresentation("password for homer"))
                    .build())
                .build();

Tuttavia, se l'utente aveva 2 account, la risposta potrebbe essere:

new FillResponse.Builder()
                .addDataset(new Dataset.Builder()
                    .setValue(id1, AutofillValue.forText("homer"), createPresentation("homer"))
                    .setValue(id2, AutofillValue.forText("D'OH!"), createPresentation("password for homer"))
                    .build())
                .addDataset(new Dataset.Builder()
                    .setValue(id1, AutofillValue.forText("flanders"), createPresentation("flanders"))
                    .setValue(id2, AutofillValue.forText("OkelyDokelyDo"), createPresentation("password for flanders"))
                    .build())
                .build();

Se il servizio non trova alcuna visualizzazione riempibile automaticamente nella struttura di visualizzazione, deve passare null a FillCallback#onSuccess(FillResponse); se il servizio ha rilevato un errore durante l'elaborazione della richiesta, deve chiamare FillCallback#onFailure(CharSequence). Per motivi di prestazioni, è fondamentale che il servizio chiami FillCallback#onSuccess(FillResponse) o FillCallback#onFailure(CharSequence) per ogni #onFillRequest(FillRequest, CancellationSignal, FillCallback) ricevuto. In caso contrario, la richiesta si verifica alla fine e verrà eliminata dal sistema Android.

"SavingUserData"><h3>Salvataggio dei dati< utente/h3>

Se il servizio è interessato anche al salvataggio dei dati compilati dall'utente, deve impostare un SaveInfo oggetto in FillResponse. Per altri dettagli ed esempi, vedere SaveInfo .

"UserAuthentication"><h3>User authentication</h3>

Il servizio può fornire un livello di sicurezza aggiuntivo richiedendo all'utente di eseguire l'autenticazione prima che un'app possa essere compilata automaticamente. L'autenticazione è in genere necessaria in 2 scenari: <ul><li>Per sbloccare i dati utente (ad esempio, usando una password principale o l'autenticazione con impronta digitale), vedere FillResponse.Builder#setAuthentication(AutofillId[], android.content.IntentSender, android.widget.RemoteViews). <li>Per sbloccare un set di dati specifico ,ad esempio fornendo un CVC per una carta di credito, vedere Dataset.Builder#setAuthentication(android.content.IntentSender). </ul>

Quando si usa l'autenticazione, è consigliabile crittografare solo i dati sensibili e lasciare non crittografate le etichette, in modo che possano essere usate nelle visualizzazioni della presentazione. Ad esempio, se l'utente ha una casa e un indirizzo aziendale, le Home etichette e Work devono essere archiviate non crittografate (poiché non hanno dati sensibili) mentre i dati dell'indirizzo potrebbero essere archiviati in una risorsa di archiviazione crittografata. Quindi, quando l'utente sceglie il Home set di dati, la piattaforma avvia il flusso di autenticazione e il servizio può decrittografare i dati sensibili.

Il meccanismo di autenticazione può essere usato anche negli scenari in cui il servizio richiede più passaggi per determinare i set di dati che possono riempire una schermata. Ad esempio, quando si riempie automaticamente un'app finanziaria in cui l'utente dispone di account per più banche, il flusso di lavoro potrebbe essere:

<ol><li>Il primo FillResponse contiene set di dati con le credenziali per l'app finanziaria, più un set di dati "falso" la cui presentazione indica "Tocca qui per le credenziali delle app bancarie". <li>Quando l'utente seleziona il set di dati falso, il servizio visualizza una finestra di dialogo con le app bancarie disponibili. <li>Quando l'utente seleziona un'app bancaria, il servizio risponde con un nuovo FillResponse contenente i set di dati per la banca. </ol>

Un altro esempio di selezione di set di dati con più passaggi è quando il servizio archivia le credenziali utente in "insiemi di credenziali": la prima risposta conterrà set di dati falsi con i nomi dell'insieme di credenziali e la risposta successiva conterrà le credenziali dell'app archiviate in tale insieme di credenziali.

"DataPartioning"><h3>Partizionamento< dati/h3>

Le visualizzazioni riempibili automaticamente in una schermata devono essere raggruppate in gruppi logici denominati "partizioni". Le partizioni tipiche sono: <ul><li>Credentials (nome utente/indirizzo di posta elettronica, password). <li>Address (via, città, stato, cap e così via). <li>Info di pagamento (numero di carta di credito, data di scadenza e codice di verifica). </ul>

Per motivi di sicurezza, quando una schermata ha più di una partizione, è fondamentale che il contenuto di un set di dati non genera più partizioni, specialmente quando una delle partizioni contiene dati non specifici dell'applicazione compilata automaticamente. Ad esempio, un set di dati non deve contenere campi per nome utente, password e informazioni sulla carta di credito. Il motivo di questa regola è che un'app dannosa potrebbe creare una struttura di visualizzazione in cui i campi della carta di credito non sono visibili, quindi quando l'utente seleziona un set di dati dall'interfaccia utente del nome utente, le informazioni sulla carta di credito vengono rilasciate all'applicazione senza la conoscenza dell'utente. Analogamente, è consigliabile proteggere sempre un set di dati contenente informazioni riservate richiedendo l'autenticazione del set di dati (vedere Dataset.Builder#setAuthentication(android.content.IntentSender)) e per includere informazioni sul campo "primario" della partizione nella presentazione personalizzata per i campi "secondari" — che impedisce a un'app dannosa di ottenere i campi "primari" senza che l'utente si renda conto che vengono rilasciati (ad esempio, un'app dannosa potrebbe avere campi per un numero di carta di credito, codice di verifica e data di scadenza creata in modo che solo quest'ultimo sia visibile; indicando in modo esplicito che la data di scadenza è correlata a un determinato numero di carta di credito, il servizio fornisce un indizio visivo per gli utenti per verificare cosa sarebbe stato rilasciato durante la selezione di tale campo.

Quando il servizio rileva che una schermata ha più partizioni, deve restituire un FillResponse oggetto con solo i set di dati per la partizione che ha originato la richiesta (ad esempio, la partizione con il android.app.assist.AssistStructure.ViewNode cui android.app.assist.AssistStructure.ViewNode#isFocused() restituisce true). Se l'utente seleziona un campo da una partizione diversa, il sistema Android eseguirà un'altra #onFillRequest(FillRequest, CancellationSignal, FillCallback) chiamata per tale partizione e così via.

Si noti che quando l'utente riempie automaticamente una partizione con i dati forniti dal servizio e l'utente non ha modificato questi campi, il valore compilato automaticamente viene inviato al servizio nelle chiamate successive (e può essere ottenuto chiamando android.app.assist.AssistStructure.ViewNode#getAutofillValue()). Ciò è utile nei casi in cui il servizio deve creare set di dati per una partizione in base alla scelta effettuata in una partizione precedente. Ad esempio, la prima risposta per una schermata con credenziali e partizioni di indirizzo potrebbe essere:

new FillResponse.Builder()
                .addDataset(new Dataset.Builder() // partition 1 (credentials)
                    .setValue(id1, AutofillValue.forText("homer"), createPresentation("homer"))
                    .setValue(id2, AutofillValue.forText("D'OH!"), createPresentation("password for homer"))
                    .build())
                .addDataset(new Dataset.Builder() // partition 1 (credentials)
                    .setValue(id1, AutofillValue.forText("flanders"), createPresentation("flanders"))
                    .setValue(id2, AutofillValue.forText("OkelyDokelyDo"), createPresentation("password for flanders"))
                    .build())
                .setSaveInfo(new SaveInfo.Builder(SaveInfo.SAVE_DATA_TYPE_PASSWORD,
                    new AutofillId[] { id1, id2 })
                        .build())
                .build();

Quindi, se l'utente ha selezionato flanders, il servizio riceve una nuova #onFillRequest(FillRequest, CancellationSignal, FillCallback) chiamata, con i valori dei campi id1 e id2 prepopolato, in modo che il servizio possa quindi recuperare l'indirizzo per l'account Flanders e restituire quanto segue FillResponse per la partizione dell'indirizzo:

new FillResponse.Builder()
                .addDataset(new Dataset.Builder() // partition 2 (address)
                    .setValue(id3, AutofillValue.forText("744 Evergreen Terrace"), createPresentation("744 Evergreen Terrace")) // street
                    .setValue(id4, AutofillValue.forText("Springfield"), createPresentation("Springfield")) // city
                    .build())
                .setSaveInfo(new SaveInfo.Builder(SaveInfo.SAVE_DATA_TYPE_PASSWORD | SaveInfo.SAVE_DATA_TYPE_ADDRESS,
                    new AutofillId[] { id1, id2 }) // username and password
                         .setOptionalIds(new AutofillId[] { id3, id4 }) // state and zipcode
                        .build())
                .build();

Quando il servizio restituisce più FillResponse, l'ultimo esegue l'override dell'oggetto precedente. Ecco perché nella SaveInfo seconda richiesta precedente sono disponibili le informazioni per entrambe le partizioni.

"PackageVerification"><h3>Verifica< pacchetto/h3>

Quando si riempiono automaticamente i dati specifici dell'app (ad esempio nome utente e password), il servizio deve verificare l'autenticità della richiesta ottenendo tutti i certificati di firma dell'app compilati automaticamente e soddisfare la richiesta solo quando corrispondono ai valori ottenuti quando i dati sono stati salvati per la prima volta — tale verifica è necessaria per evitare tentativi di phishing da parte delle app trasferite localmente nel dispositivo con lo stesso nome del pacchetto di un'altra app. Ecco un esempio su come ottenere questo risultato eseguendo l'hashing dei certificati di firma:

private String getCertificatesHash(String packageName) throws Exception {
              PackageManager pm = mContext.getPackageManager();
              PackageInfo info = pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
              ArrayList<String> hashes = new ArrayList<>(info.signatures.length);
              for (Signature sig : info.signatures) {
                byte[] cert = sig.toByteArray();
                MessageDigest md = MessageDigest.getInstance("SHA-256");
                md.update(cert);
                hashes.add(toHexString(md.digest()));
              }
              Collections.sort(hashes);
              StringBuilder hash = new StringBuilder();
              for (int i = 0; i < hashes.size(); i++) {
                hash.append(hashes.get(i));
              }
              return hash.toString();
            }

Se il servizio non ha archiviato i dati dei certificati di firma la prima volta che i dati sono stati salvati — ad esempio, poiché i dati sono stati creati da una versione precedente dell'app che non ha usato il framework di riempimento automatico — Il servizio dovrebbe avvisare l'utente che l'autenticità dell'app non può essere confermata (vedere un esempio su come visualizzare tale avviso nella sezione Sicurezza Web di seguito) e, se l'utente accetta, il servizio potrebbe salvare i dati dai ceriticati di firma per un uso futuro.

"IgnoringViews"><h3>Ignora visualizzazioni</h3>

Se il servizio trova visualizzazioni che non possono essere riempite automaticamente (ad esempio, un campo di testo che rappresenta la risposta a una richiesta captcha), deve contrassegnare tali visualizzazioni come ignorate chiamando FillResponse.Builder#setIgnoredIds(AutofillId...) in modo che il sistema non attivi una nuova #onFillRequest(FillRequest, CancellationSignal, FillCallback) visualizzazione quando queste visualizzazioni sono attivate.

"WebSecurity"><h3>Web security</h3>

Quando si gestiscono le richieste di riempimento automatico che rappresentano le pagine Web (in genere visualizzano strutture la android.app.assist.AssistStructure.ViewNode#getClassName() cui radice è un android.webkit.WebView), il servizio deve eseguire i passaggi seguenti per verificare se la struttura può essere riempita automaticamente con i dati associati all'app che la richiede:

<ol><li>Utilizzare per android.app.assist.AssistStructure.ViewNode#getWebDomain() ottenere l'origine del documento. <li>Ottenere il dominio canonico usando l'elenco dei suffissi pubblici (vedere l'esempio seguente). <li>Usa collegamenti asset digitali per ottenere il nome del pacchetto e l'impronta digitale del certificato del pacchetto corrispondente al dominio canonico. <li>Assicurarsi che l'impronta digitale del certificato corrisponda al valore restituito da Gestione pacchetti (vedere la sezione "Verifica del pacchetto" sopra). </ol>

Ecco un esempio su come ottenere il dominio canonico usando Guava:

private static String getCanonicalDomain(String domain) {
              InternetDomainName idn = InternetDomainName.from(domain);
              while (idn != null && !idn.isTopPrivateDomain()) {
                idn = idn.parent();
              }
              return idn == null ? null : idn.toString();
            }

"WebSecurityDisclaimer">

Se l'associazione tra il dominio Web e il pacchetto dell'app non può essere verificata tramite i passaggi precedenti, ma il servizio ritiene che sia appropriato compilare le credenziali persistenti archiviate per il dominio Web, il servizio deve avvisare prima l'utente della potenziale perdita di dati e chiedere all'utente di confermare. Ad esempio, il servizio potrebbe:

<ol><li>Creare un set di dati che richiede Dataset.Builder#setAuthentication(android.content.IntentSender) authentication lo sblocco. <li>Includere il dominio Web nella presentazione personalizzata per .Dataset.Builder#setValue(AutofillId, AutofillValue, android.widget.RemoteViews) dataset value <li>Quando l'utente seleziona tale set di dati, mostra una finestra di dialogo di dichiarazione di non responsabilità che spiega che l'app richiede credenziali per un dominio Web, ma il servizio non è riuscito a verificare se l'app è proprietaria di tale dominio. Se l'utente accetta, il servizio può sbloccare il set di dati. <li>Analogamente, quando si aggiunge un SaveInfo oggetto per la richiesta, il servizio deve includere la dichiarazione di non responsabilità precedente in SaveInfo.Builder#setDescription(CharSequence). </ol>

Questa stessa procedura può essere usata anche quando i dati riempibili automaticamente sono contenuti all'interno di un IFRAMEoggetto , nel qual caso WebView genera un nuovo contesto di riempimento automatico quando un nodo all'interno IFRAME di è attivo, con il nodo radice contenente l'attributo IFRAMEdi src su android.app.assist.AssistStructure.ViewNode#getWebDomain(). Un caso d'uso tipico e legittimo per questo scenario è un'app finanziaria che consente all'utente di accedere su conti bancari diversi. Ad esempio, un'app my_financial_app finanziaria può usare un controllo WebView che carica il contenuto da banklogin.my_financial_app.com, che contiene un IFRAME nodo il cui src attributo è login.some_bank.com. Quando soddisfa tale richiesta, il servizio potrebbe aggiungere una Dataset.Builder#setAuthentication(android.content.IntentSender) authenticated dataset la cui presentazione visualizza "Nome utente per some_bank.com" e "Password per some_bank.com". Quando quindi l'utente tocca una di queste opzioni, il servizio visualizza la finestra di dialogo di dichiarazione di non responsabilità che spiega che la selezione di tale opzione rilascia le login.some_bank.com credenziali a my_financial_app. Se l'utente accetta, il servizio restituisce un set di dati sbloccato con le some_bank.com credenziali.

<b Nota:>/b<> Il servizio di riempimento automatico potrebbe anche aggiungere app browser note in un elenco di elementi consentiti e ignorare le verifiche precedenti, purché il servizio possa verificare l'autenticità dell'app browser controllandone il certificato di firma.

"MultipleStepsSave"><h3>Salvataggio quando i dati vengono suddivisi in più schermate</h3>

Le app spesso suddivideno i dati utente in più schermate nella stessa attività, in particolare nelle attività usate per creare un nuovo account utente. Ad esempio, la prima schermata richiede un nome utente e, se il nome utente è disponibile, passa a una seconda schermata, che richiede una password.

È difficile gestire il salvataggio per il riempimento automatico in queste situazioni, perché il servizio di riempimento automatico deve attendere fino a quando l'utente immette entrambi i campi prima che sia possibile visualizzare l'interfaccia utente del salvataggio automatico. Ma può essere eseguita seguendo questa procedura:

<ol><li>Nel primo #onFillRequest(FillRequest, CancellationSignal, FillCallback) fill request, il servizio aggiunge un nella FillResponse.Builder#setClientState(android.os.Bundle) client state bundle risposta, contenente gli ID riempimento automatico dei campi parziali presenti nella schermata. <li>Nel secondo #onFillRequest(FillRequest, CancellationSignal, FillCallback) fill request, il servizio recupera l'oggetto FillRequest#getClientState() client state bundle, ottiene gli ID di riempimento automatico impostati nella richiesta precedente dallo stato del client e aggiunge questi ID e SaveInfo#FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE all'oggetto SaveInfo usato nella seconda risposta. <li>In #onSaveRequest(SaveRequest, SaveCallback) save request, il servizio usa il valore appropriato FillContext fill contexts per ottenere il valore di ogni campo (è presente un contesto di riempimento per ogni richiesta di riempimento). </ol>

Ad esempio, in un'app che usa 2 passaggi per i campi nome utente e password, il flusso di lavoro sarà:

// On first fill request
             AutofillId usernameId = // parse from AssistStructure;
             Bundle clientState = new Bundle();
             clientState.putParcelable("usernameId", usernameId);
             fillCallback.onSuccess(
               new FillResponse.Builder()
                   .setClientState(clientState)
                   .setSaveInfo(new SaveInfo
                        .Builder(SaveInfo.SAVE_DATA_TYPE_USERNAME, new AutofillId[] {usernameId})
                        .build())
                   .build());

             // On second fill request
             Bundle clientState = fillRequest.getClientState();
             AutofillId usernameId = clientState.getParcelable("usernameId");
             AutofillId passwordId = // parse from AssistStructure
             clientState.putParcelable("passwordId", passwordId);
             fillCallback.onSuccess(
               new FillResponse.Builder()
                   .setClientState(clientState)
                   .setSaveInfo(new SaveInfo
                        .Builder(SaveInfo.SAVE_DATA_TYPE_USERNAME | SaveInfo.SAVE_DATA_TYPE_PASSWORD,
                                 new AutofillId[] {usernameId, passwordId})
                        .setFlags(SaveInfo.FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE)
                        .build())
                   .build());

             // On save request
             Bundle clientState = saveRequest.getClientState();
             AutofillId usernameId = clientState.getParcelable("usernameId");
             AutofillId passwordId = clientState.getParcelable("passwordId");
             List<FillContext> fillContexts = saveRequest.getFillContexts();

             FillContext usernameContext = fillContexts.get(0);
             ViewNode usernameNode = findNodeByAutofillId(usernameContext.getStructure(), usernameId);
             AutofillValue username = usernameNode.getAutofillValue().getTextValue().toString();

             FillContext passwordContext = fillContexts.get(1);
             ViewNode passwordNode = findNodeByAutofillId(passwordContext.getStructure(), passwordId);
             AutofillValue password = passwordNode.getAutofillValue().getTextValue().toString();

             save(username, password);

"Privacy"><h3>Privacy</h3>

Il #onFillRequest(FillRequest, CancellationSignal, FillCallback) metodo viene chiamato senza il contenuto dell'utente. Il sistema Android rimuove alcune proprietà dell'oggetto android.app.assist.AssistStructure.ViewNode view nodes passato a questa chiamata, ma non tutte. Ad esempio, i dati forniti negli android.view.ViewStructure.HtmlInfo oggetti impostati da android.webkit.WebView non vengono mai rimossi.

Poiché questi dati potrebbero contenere informazioni personali (informazioni personali, ad esempio nome utente o indirizzo di posta elettronica), il servizio deve usarlo solo in locale (ad esempio, nel processo dell'app) per scopi euristici, ma non deve essere inviato a server esterni.

"FieldClassification"><h3>Metrics and field classification</h3>

Il servizio può chiamare #getFillEventHistory() per ottenere metriche che rappresentano le azioni dell'utente e quindi usare queste metriche per migliorarne l'euristica.

Prima di Android android.os.Build.VERSION_CODES#P, le metriche riguardavano solo gli scenari in cui il servizio sapeva come riempire automaticamente un'attività, ma Android android.os.Build.VERSION_CODES#P ha introdotto un nuovo meccanismo denominato classificazione dei campi, che consente al servizio di classificare dinamicamente il significato dei campi in base ai dati utente esistenti noti dal servizio.

In genere, la classificazione dei campi può essere usata per rilevare i campi che possono essere compilati automaticamente con i dati utente non associati a un'app specifica— ad esempio posta elettronica e indirizzo fisico. Dopo che il servizio identifica che un campo di questo tipo è stato compilato manualmente dall'utente, il servizio potrebbe usare questo segnale per migliorare l'euristica nelle richieste successive, ad esempio dedurndo quali ID risorsa sono associati ai campi noti.

Il flusso di lavoro di classificazione dei campi prevede 4 passaggi:

<ol><li>Impostare i dati utente tramite AutofillManager#setUserData(UserData). Questi dati vengono memorizzati nella cache fino al riavvio del sistema (o il servizio è disabilitato), quindi non è necessario impostare per tutte le richieste. <li>Identificare i campi da analizzare chiamando FillResponse.Builder#setFieldClassificationIds(AutofillId...). <li>Verificare i risultati tramite FillEventHistory.Event#getFieldsClassification(). <li>Utilizzare i risultati per creare Dataset dinamicamente oggetti o SaveInfo nelle richieste successive. </ol>

La classificazione dei campi è un'operazione costosa e deve essere usata attentamente, altrimenti può raggiungere il limite di velocità e essere bloccata dal sistema Android. Idealmente, deve essere usato solo nei casi in cui il servizio non è riuscito a determinare come un'attività può essere riempita automaticamente, ma ha un forte sospetto che potrebbe. Ad esempio, se un'attività ha quattro o più campi e uno di essi è un elenco, è probabile che si tratta di campi di indirizzo (ad esempio indirizzo, città, stato e codice postale).

"CompatibilityMode"><h3>Compatibility mode</h3>

Le app che usano widget Android standard supportano la compilazione automatica predefinita e devono fare molto poco per migliorare l'esperienza utente (annotando le visualizzazioni riempibili automaticamente e fornendo suggerimenti per il riempimento automatico). Tuttavia, alcune app (in genere browser) eseguono il proprio rendering e il contenuto sottoposto a rendering può contenere una struttura semantica che deve essere visualizzata nel framework di riempimento automatico. La piattaforma espone le API per ottenere questo risultato, ma potrebbe richiedere del tempo fino a quando queste app implementano il supporto del riempimento automatico.

Per abilitare il riempimento automatico per tali app, la piattaforma fornisce una modalità di compatibilità in cui la piattaforma eseguirà il fallback alle API di accessibilità per generare lo stato segnalato ai servizi di riempimento automatico e compilare i dati. Questa modalità deve essere richiesta in modo esplicito per un determinato pacchetto fino a un codice di versione massima specificato che consente il percorso di migrazione pulito quando l'app di destinazione inizia a supportare il riempimento automatico in modo nativo. Si noti che l'abilitazione della compatibilità può ridurre le prestazioni per il pacchetto di destinazione e deve essere usata con cautela. La piattaforma supporta la creazione di un elenco di elementi consentiti per includere quali pacchetti possono essere destinati in modalità di compatibilità per assicurarsi che questa modalità venga usata solo quando necessario e finché necessario.

È possibile richiedere la modalità di compatibilità per i pacchetti di interesse per la risorsa meta-dati associata al servizio. Di seguito è riportata una dichiarazione di servizio di esempio:

&lt;service android:name=".MyAutofillService"
                         android:permission="android.permission.BIND_AUTOFILL_SERVICE"&gt;
                &lt;intent-filter&gt;
                    &lt;action android:name="android.service.autofill.AutofillService" /&gt;
                &lt;/intent-filter&gt;
                &lt;meta-data android:name="android.autofill" android:resource="@xml/autofillservice" /&gt;
            &lt;/service&gt;

Nel file XML è possibile specificare uno o più pacchetti per i quali abilitare la modalità di compatibilità. Di seguito è riportata una dichiarazione di metadati di esempio:

&lt;autofill-service xmlns:android="http://schemas.android.com/apk/res/android"&gt;
                &lt;compatibility-package android:name="foo.bar.baz" android:maxLongVersionCode="1000000000"/&gt;
            &lt;/autofill-service&gt;

Si noti che la modalità di compatibilità presenta limitazioni, ad esempio: <ul><li>Nessuna richiesta di riempimento automatico manuale. Di conseguenza, la FillRequestFillRequest#getFlags() flags bandiera non è mai stata FillRequest#FLAG_MANUAL_REQUEST . <li>Il valore dei campi password è probabilmente mascherato— ad esempio, **** anziché 1234. Di conseguenza, è necessario prestare attenzione quando si usano questi valori per evitare di aggiornare i dati utente con input non valido. Ad esempio, quando si analizza FillRequest e si rileva un campo password, è possibile verificare se android.app.assist.AssistStructure.ViewNode#getInputType() input type contiene flag password e, in caso affermativo, non aggiungerlo all'oggetto SaveInfo . <li>Il contesto di riempimento automatico non è sempre quando AutofillManager#commit() committed viene inviato un modulo HTML. Di conseguenza, è necessario usare altri meccanismi per attivare il salvataggio, ad esempio impostando il SaveInfo#FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE flag su SaveInfo.Builder#setFlags(int) o usando SaveInfo.Builder#setTriggerId(AutofillId). <li>Browser spesso forniscono il proprio sistema di gestione del riempimento automatico. Quando il browser e la piattaforma eseguono il rendering di una finestra di dialogo di riempimento automatico contemporaneamente, il risultato può generare confusione per l'utente. Tali browser offrono in genere un'opzione che consente agli utenti di disabilitare il riempimento automatico, pertanto il servizio dovrebbe anche consentire agli utenti di disabilitare la modalità di compatibilità per app specifiche. In questo modo, spetta all'utente decidere quale meccanismo di riempimento automatico— il browser o il s&mdash della piattaforma; deve essere usato. </ul>

per android.service.autofill.AutofillService.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

Costruttori

Nome	Descrizione
AutofillService()	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.
AutofillService(IntPtr, JniHandleOwnership)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.

Campi

Nome	Descrizione
AccessibilityService	Usare con `#getSystemService(String)` per recuperare un `android.view.accessibility.AccessibilityManager` oggetto per fornire all'utente commenti e suggerimenti per gli eventi dell'interfaccia utente tramite i listener di eventi registrati. (Ereditato da Context)
AccountService	Usare con `#getSystemService(String)` per recuperare un `android.accounts.AccountManager` oggetto per la ricezione di finalità alla volta della scelta. (Ereditato da Context)
ActivityService	Usare con `#getSystemService(String)` per recuperare un `android.app.ActivityManager` oggetto per interagire con lo stato del sistema globale. (Ereditato da Context)
AdvancedProtectionService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.security.advancedprotection.AdvancedProtectionManager` (Ereditato da Context)
AlarmService	Usare con `#getSystemService(String)` per recuperare un `android.app.AlarmManager` oggetto per la ricezione di finalità alla volta della scelta. (Ereditato da Context)
AppFunctionService	Usare con `#getSystemService(String)` per recuperare un `AppFunctionManager` oggetto per l'esecuzione di funzioni dell'app. (Ereditato da Context)
AppOpsService	Usare con `#getSystemService(String)` per recuperare un `android.app.AppOpsManager` oggetto per tenere traccia delle operazioni dell'applicazione nel dispositivo. (Ereditato da Context)
AppSearchService	Usare con `#getSystemService(String)` per recuperare un oggetto per l'indicizzazione `android.app.appsearch.AppSearchManager` e l'esecuzione di query sui dati dell'app gestiti dal sistema. (Ereditato da Context)
AppwidgetService	Usare con `#getSystemService(String)` per recuperare un `android.appwidget.AppWidgetManager` oggetto per l'accesso ad AppWidgets. (Ereditato da Context)
AudioService	Usare con `#getSystemService(String)` per recuperare un `android.media.AudioManager` oggetto per la gestione della gestione del volume, delle modalità ringer e del routing audio. (Ereditato da Context)
BatteryService	Usare con `#getSystemService(String)` per recuperare un `android.os.BatteryManager` oggetto per la gestione dello stato della batteria. (Ereditato da Context)
BindAllowActivityStarts	Obsoleti. Flag per `#bindService`: se l'associazione da un'app visibile, il servizio associato può avviare un'attività in background. (Ereditato da Context)
BindExternalServiceLong	Funziona allo stesso modo di `#BIND_EXTERNAL_SERVICE`, ma è definito come un `long` valore compatibile con `BindServiceFlags`. (Ereditato da Context)
BindNotPerceptible	Obsoleti. Flag per `#bindService`: se l'associazione da un'app visibile o percepibile dall'utente, ridurre l'importanza del servizio di destinazione al di sotto del livello percepibile. (Ereditato da Context)
BindPackageIsolatedProcess	Obsoleti. Flag per `#bindIsolatedService`: associare il servizio a un processo isolato condiviso, ma solo con altri servizi isolati dallo stesso pacchetto che dichiara lo stesso nome di processo. (Ereditato da Context)
BindSharedIsolatedProcess	Obsoleti. Flag per `#bindIsolatedService`: associare il servizio in un processo isolato condiviso. (Ereditato da Context)
BiometricService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.biometrics.BiometricManager` oggetto per la gestione dell'autenticazione biometrica e pin/pattern/password. (Ereditato da Context)
BlobStoreService	Usare con `#getSystemService(String)` per recuperare un `android.app.blob.BlobStoreManager` oggetto per contribuire e accedere ai BLOB di dati dall'archivio BLOB gestito dal sistema. (Ereditato da Context)
BluetoothService	Usare con `#getSystemService(String)` per recuperare un `android.bluetooth.BluetoothManager` oggetto per l'uso del Bluetooth. (Ereditato da Context)
BugreportService	Servizio per acquisire un bugreport. (Ereditato da Context)
CameraService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.camera2.CameraManager` oggetto per interagire con i dispositivi della fotocamera. (Ereditato da Context)
CaptioningService	Usare con `#getSystemService(String)` per recuperare un `android.view.accessibility.CaptioningManager` oggetto per ottenere le proprietà di didascalia e ascoltare le modifiche nelle preferenze di didascalia. (Ereditato da Context)
CarrierConfigService	Usare con `#getSystemService(String)` per recuperare un `android.telephony.CarrierConfigManager` oggetto per la lettura dei valori di configurazione del gestore telefonico. (Ereditato da Context)
ChooserService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.service.chooser.ChooserManager`. (Ereditato da Context)
ClipboardService	Utilizzare con `#getSystemService(String)` per recuperare un `android.content.ClipboardManager` oggetto per accedere e modificare il contenuto degli Appunti globali. (Ereditato da Context)
CompanionDeviceService	Usare con `#getSystemService(String)` per recuperare un `android.companion.CompanionDeviceManager` oggetto per la gestione dei dispositivi complementari (Ereditato da Context)
ConnectivityDiagnosticsService	Usare con `#getSystemService(String)` per recuperare un `android.net.ConnectivityDiagnosticsManager` oggetto per l'esecuzione della diagnostica della connettività di rete e la ricezione di informazioni sulla connettività di rete dal sistema. (Ereditato da Context)
ConnectivityService	Utilizzare con `#getSystemService(String)` per recuperare un `android.net.ConnectivityManager` oggetto per la gestione delle connessioni di rete. (Ereditato da Context)
ConsumerIrService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.ConsumerIrManager` oggetto per trasmettere segnali infrarossi dal dispositivo. (Ereditato da Context)
ContactKeysService	Usare con `#getSystemService(String)` per recuperare un `E2eeContactKeysManager` oggetto per la gestione delle chiavi di contatto. (Ereditato da Context)
CredentialService	Usare con `#getSystemService(String)` per recuperare un `android.credentials.CredentialManager` oggetto per autenticare un utente nell'app. (Ereditato da Context)
CrossProfileAppsService	Usare con `#getSystemService(String)` per recuperare un `android.content.pm.CrossProfileApps` oggetto per le operazioni tra profili. (Ereditato da Context)
DeviceIdDefault	ID dispositivo predefinito, ovvero l'ID del dispositivo primario (non virtuale). (Ereditato da Context)
DeviceIdInvalid	ID dispositivo non valido. (Ereditato da Context)
DeviceLockService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.devicelock.DeviceLockManager`. (Ereditato da Context)
DevicePolicyService	Usare con `#getSystemService(String)` per recuperare un `android.app.admin.DevicePolicyManager` oggetto per l'uso della gestione globale dei criteri dei dispositivi. (Ereditato da Context)
DisplayHashService	Usare con `#getSystemService(String)` per accedere `android.view.displayhash.DisplayHashManager` per gestire gli hash di visualizzazione. (Ereditato da Context)
DisplayService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.display.DisplayManager` oggetto per interagire con i dispositivi di visualizzazione. (Ereditato da Context)
DomainVerificationService	Usare con `#getSystemService(String)` per accedere `android.content.pm.verify.domain.DomainVerificationManager` per recuperare l'approvazione e lo stato utente per i domini Web dichiarati. (Ereditato da Context)
DownloadService	Usare con `#getSystemService(String)` per recuperare un `android.app.DownloadManager` oggetto per richiedere download HTTP. (Ereditato da Context)
DropboxService	Usare con `#getSystemService(String)` per recuperare un'istanza `android.os.DropBoxManager` per la registrazione dei log di diagnostica. (Ereditato da Context)
EuiccService	Usare con `#getSystemService(String)` per recuperare un `android.telephony.euicc.EuiccManager` oggetto per gestire l'eUICC del dispositivo (SIM incorporato). (Ereditato da Context)
ExtraFillResponse	Nome dell'elemento `FillResponse` aggiuntivo utilizzato per restituire una risposta di riempimento ritardata.
FileIntegrityService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.security.FileIntegrityManager`. (Ereditato da Context)
FingerprintService	Utilizzare con `#getSystemService(String)` per recuperare un `android.hardware.fingerprint.FingerprintManager` oggetto per la gestione delle impronte digitali. (Ereditato da Context)
GameService	Usare con `#getSystemService(String)` per recuperare un oggetto `GameManager`. (Ereditato da Context)
GrammaticalInflectionService	Usare con `#getSystemService(String)` per recuperare un oggetto `GrammaticalInflectionManager`. (Ereditato da Context)
HardwarePropertiesService	Usare con `#getSystemService(String)` per recuperare un `android.os.HardwarePropertiesManager` oggetto per l'accesso al servizio delle proprietà hardware. (Ereditato da Context)
HealthconnectService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.health.connect.HealthConnectManager`. (Ereditato da Context)
InputMethodService	Usare con `#getSystemService(String)` per recuperare un `android.view.inputmethod.InputMethodManager` oggetto per l'accesso ai metodi di input. (Ereditato da Context)
InputService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.input.InputManager` oggetto per interagire con i dispositivi di input. (Ereditato da Context)
IpsecService	Usare con `#getSystemService(String)` per recuperare un `android.net.IpSecManager` oggetto per crittografare socket o reti con IPSec. (Ereditato da Context)
JobSchedulerService	Usare con `#getSystemService(String)` per recuperare un'istanza `android.app.job.JobScheduler` per la gestione di attività in background occasionali. (Ereditato da Context)
KeyguardService	Usare con `#getSystemService(String)` per recuperare un `android.app.KeyguardManager` oggetto per il controllo della guardia chiave. (Ereditato da Context)
KeystoreService	Usare con `#getSystemService(String)` per recuperare un `android.security.keystore.KeyStoreManager` oggetto per l'accesso alle funzioni dell'archivio chiavi Android. (Ereditato da Context)
LauncherAppsService	Usare con `#getSystemService(String)` per recuperare un `android.content.pm.LauncherApps` oggetto per l'esecuzione di query e il monitoraggio di app avviabili tra i profili di un utente. (Ereditato da Context)
LayoutInflaterService	Usare con `#getSystemService(String)` per recuperare un `android.view.LayoutInflater` oggetto per l'aumento delle risorse di layout in questo contesto. (Ereditato da Context)
LocaleService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.app.LocaleManager`. (Ereditato da Context)
LocationService	Usare con `#getSystemService(String)` per recuperare un `android.location.LocationManager` oggetto per controllare gli aggiornamenti della posizione. (Ereditato da Context)
MediaCommunicationService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.media.MediaCommunicationManager` per la gestione di `android.media.MediaSession2`. (Ereditato da Context)
MediaMetricsService	Usare con `#getSystemService(String)` per recuperare un `android.media.metrics.MediaMetricsManager` oggetto per interagire con le metriche multimediali nel dispositivo. (Ereditato da Context)
MediaProjectionService	Usare con `#getSystemService(String)` per recuperare un'istanza `android.media.projection.MediaProjectionManager` per la gestione delle sessioni di proiezione multimediale. (Ereditato da Context)
MediaQualityService	Usare con `#getSystemService(String)` per recuperare un `android.media.quality.MediaQualityManager` oggetto per standardizzare i parametri dell'API immagine e audio. (Ereditato da Context)
MediaRouterService	Usare con `#getSystemService` per recuperare un `android.media.MediaRouter` oggetto per il controllo e la gestione del routing dei supporti. (Ereditato da Context)
MediaSessionService	Usare con `#getSystemService(String)` per recuperare un `android.media.session.MediaSessionManager` oggetto per la gestione delle sessioni multimediali. (Ereditato da Context)
MidiService	Utilizzare con `#getSystemService(String)` per recuperare un `android.media.midi.MidiManager` oggetto per accedere al servizio MIDI. (Ereditato da Context)
NetworkStatsService	Usare con `#getSystemService(String)` per recuperare un `android.app.usage.NetworkStatsManager` oggetto per l'esecuzione di query sulle statistiche di utilizzo della rete. (Ereditato da Context)
NfcService	Usare con `#getSystemService(String)` per recuperare un `android.nfc.NfcManager` oggetto per l'uso di NFC. (Ereditato da Context)
NotificationService	Usare con `#getSystemService(String)` per recuperare un `android.app.NotificationManager` oggetto per informare l'utente di eventi in background. (Ereditato da Context)
NsdService	Usare con `#getSystemService(String)` per recuperare un `android.net.nsd.NsdManager` oggetto per la gestione della gestione dell'individuazione dei servizi di rete (Ereditato da Context)
OverlayService	Usare con `#getSystemService(String)` per recuperare un `android.content.om.OverlayManager` oggetto per la gestione dei pacchetti di sovrimpressione. (Ereditato da Context)
PeopleService	Usare con `#getSystemService(String)` per accedere `PeopleManager` a per interagire con le conversazioni pubblicate. (Ereditato da Context)
PerformanceHintService	Usare con `#getSystemService(String)` per recuperare un `android.os.PerformanceHintManager` oggetto per accedere al servizio di hint per le prestazioni. (Ereditato da Context)
PersistentDataBlockService	Usare con `#getSystemService(String)` per recuperare un'istanza `android.service.persistentdata.PersistentDataBlockManager` per interagire con un dispositivo di archiviazione che si trova tra i ripristini delle impostazioni predefinite. (Ereditato da Context)
PowerService	Usare con `#getSystemService(String)` per recuperare un `android.os.PowerManager` oggetto per il controllo del risparmio energia, inclusi i "blocchi di riattivazione", che consentono di mantenere attivo il dispositivo durante l'esecuzione di attività lunghe. (Ereditato da Context)
PrintService	`android.print.PrintManager` per la stampa e la gestione di stampanti e attività di stampa. (Ereditato da Context)
ProfilingService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.os.ProfilingManager`. (Ereditato da Context)
ReceiverExported	Obsoleti. Flag per `#registerReceiver`: il ricevitore può ricevere trasmissioni da altre app. (Ereditato da Context)
ReceiverNotExported	Obsoleti. Flag per `#registerReceiver`: il ricevitore non può ricevere trasmissioni da altre app. (Ereditato da Context)
ReceiverVisibleToInstantApps	Obsoleti. Flag per `#registerReceiver`: il ricevitore può ricevere trasmissioni da App istantanee. (Ereditato da Context)
RestrictionsService	Usare con `#getSystemService(String)` per recuperare un `android.content.RestrictionsManager` oggetto per recuperare le restrizioni dell'applicazione e richiedere autorizzazioni per le operazioni con restrizioni. (Ereditato da Context)
RoleService	Usare con `#getSystemService(String)` per recuperare un `android.app.role.RoleManager` oggetto per la gestione dei ruoli. (Ereditato da Context)
SatelliteService	Usare con `#getSystemService(String)` per recuperare un `android.telephony.satellite.SatelliteManager` oggetto per l'accesso alle funzionalità satellite. (Ereditato da Context)
SearchService	Utilizzare con `#getSystemService(String)` per recuperare un `android.app.SearchManager` oggetto per la gestione delle ricerche. (Ereditato da Context)
SecurityStateService	Usare con `#getSystemService(String)` per recuperare un `android.os.SecurityStateManager` oggetto per l'accesso al servizio di gestione dello stato di sicurezza. (Ereditato da Context)
SensorService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.SensorManager` oggetto per l'accesso ai sensori. (Ereditato da Context)
ServiceInterface	Oggetto `Intent` che deve essere dichiarato come gestito dal servizio.
ServiceMetaData	Nome con cui un componente AutoFillService pubblica informazioni su se stesso.
ShortcutService	Usare con `#getSystemService(String)` per recuperare un `android.content.pm.ShortcutManager` oggetto per l'accesso al servizio di scelta rapida dell'utilità di avvio. (Ereditato da Context)
StatusBarService	Usare con `#getSystemService(String)` per recuperare un `android.app.StatusBarManager` oggetto per interagire con la barra di stato e le impostazioni rapide. (Ereditato da Context)
StopForegroundDetach	Obsoleti. Selettore per stopForeground(int): se impostato, la notifica fornita in precedenza a startForeground(int, Notification) verrà scollegata dal ciclo di vita del servizio. (Ereditato da Service)
StopForegroundLegacy	Questa costante è stata deprecata nel livello API 33. (Ereditato da Service)
StopForegroundRemove	Obsoleti. Selettore per stopForeground(int): se specificato, la notifica fornita in precedenza a startForeground(int, Notification) verrà annullata e rimossa dalla visualizzazione. (Ereditato da Service)
StorageService	Usare con `#getSystemService(String)` per recuperare un `android.os.storage.StorageManager` oggetto per l'accesso alle funzioni di archiviazione di sistema. (Ereditato da Context)
StorageStatsService	Usare con `#getSystemService(String)` per recuperare un `android.app.usage.StorageStatsManager` oggetto per l'accesso alle statistiche di archiviazione del sistema. (Ereditato da Context)
SystemHealthService	Usare con `#getSystemService(String)` per recuperare un `android.os.health.SystemHealthManager` oggetto per l'accesso alle metriche di integrità del sistema (batteria, alimentazione, memoria e così via). (Ereditato da Context)
TelecomService	Usare con `#getSystemService(String)` per recuperare un `android.telecom.TelecomManager` oggetto per gestire le funzionalità correlate alle telecomunicazioni del dispositivo. (Ereditato da Context)
TelephonyImsService	Usare con `#getSystemService(String)` per recuperare un oggetto `android.telephony.ims.ImsManager`. (Ereditato da Context)
TelephonyPhoneNumberService	Usare con `#getSystemService(String)` per recuperare un `android.telephony.PhoneNumberManager` oggetto per l'analisi dei numeri di telefono. (Ereditato da Context)
TelephonyService	Utilizzare con `#getSystemService(String)` per recuperare un `android.telephony.TelephonyManager` oggetto per la gestione delle funzionalità di telefonia del dispositivo. (Ereditato da Context)
TelephonySubscriptionService	Utilizzare con `#getSystemService(String)` per recuperare un `android.telephony.SubscriptionManager` oggetto per la gestione delle sottoscrizioni di telefonia del dispositivo. (Ereditato da Context)
TetheringService	Usare con `#getSystemService(String)` per recuperare un `android.net.TetheringManager` oggetto per la gestione delle funzioni di tethering. (Ereditato da Context)
TextClassificationService	Usare con `#getSystemService(String)` per recuperare un `TextClassificationManager` oggetto per i servizi di classificazione del testo. (Ereditato da Context)
TextServicesManagerService	Usare con `#getSystemService(String)` per recuperare un `android.view.textservice.TextServicesManager` oggetto per l'accesso ai servizi di testo. (Ereditato da Context)
TvAdService	Usare con `#getSystemService(String)` per recuperare un `android.media.tv.ad.TvAdManager` oggetto per interagire con i servizi pubblicitari sul lato client TV nel dispositivo. (Ereditato da Context)
TvInputService	Usare con `#getSystemService(String)` per recuperare un `android.media.tv.TvInputManager` oggetto per interagire con gli input TV nel dispositivo. (Ereditato da Context)
TvInteractiveAppService	Usare con `#getSystemService(String)` per recuperare un `android.media.tv.interactive.TvInteractiveAppManager` oggetto per interagire con le applicazioni interattive TV nel dispositivo. (Ereditato da Context)
UiModeService	Usare con `#getSystemService(String)` per recuperare un `android.app.UiModeManager` oggetto per il controllo delle modalità dell'interfaccia utente. (Ereditato da Context)
UsageStatsService	Usare con `#getSystemService(String)` per recuperare un `android.app.usage.UsageStatsManager` oggetto per l'esecuzione di query sulle statistiche di utilizzo dei dispositivi. (Ereditato da Context)
UsbService	Usare con `#getSystemService(String)` per recuperare un `android.hardware.usb.UsbManager` oggetto per l'accesso ai dispositivi USB (come host USB) e per controllare il comportamento di questo dispositivo come dispositivo USB. (Ereditato da Context)
UserService	Usare con `#getSystemService(String)` per recuperare un `android.os.UserManager` oggetto per la gestione degli utenti nei dispositivi che supportano più utenti. (Ereditato da Context)
VibratorManagerService	Usare con `#getSystemService(String)` per recuperare un `android.os.VibratorManager` oggetto per accedere ai vibratori del dispositivo, interagire con i singoli e riprodurre effetti sincronizzati su più vibratori. (Ereditato da Context)
VibratorService	Usare con `#getSystemService(String)` per recuperare un `android.os.Vibrator` oggetto per interagire con l'hardware di vibrazione. (Ereditato da Context)
VirtualDeviceService	Usare con `#getSystemService(String)` per recuperare un `android.companion.virtual.VirtualDeviceManager` oggetto per la gestione dei dispositivi virtuali. (Ereditato da Context)
VpnManagementService	Usare con `#getSystemService(String)` per recuperare un `android.net.VpnManager` oggetto per gestire i profili per la VPN predefinita della piattaforma. (Ereditato da Context)
WallpaperService	Usare con `#getSystemService(String)` per recuperare un com. (Ereditato da Context)
WifiAwareService	Usare con `#getSystemService(String)` per recuperare un `android.net.wifi.aware.WifiAwareManager` oggetto per la gestione di Wi-Fi Aware. (Ereditato da Context)
WifiP2pService	Usare con `#getSystemService(String)` per recuperare un `android.net.wifi.p2p.WifiP2pManager` oggetto per la gestione delle Wi-Fi connessioni peer-to-peer. (Ereditato da Context)
WifiRttRangingService	Usare con `#getSystemService(String)` per recuperare un `android.net.wifi.rtt.WifiRttManager` oggetto per l'intervallo di dispositivi con wifi. (Ereditato da Context)
WifiService	Usare con `#getSystemService(String)` per recuperare un `android.net.wifi.WifiManager` oggetto per la gestione dell'accesso Wi-Fi. (Ereditato da Context)
WindowService	Usare con `#getSystemService(String)` per recuperare un `android.view.WindowManager` oggetto per l'accesso al gestore finestre del sistema. (Ereditato da Context)

Proprietà

Nome	Descrizione
Application	Restituisce l'applicazione proprietaria del servizio. (Ereditato da Service)
ApplicationContext	Restituisce il contesto del singolo oggetto Application globale del processo corrente. (Ereditato da ContextWrapper)
ApplicationInfo	Restituisce le informazioni complete sull'applicazione per il pacchetto di questo contesto. (Ereditato da ContextWrapper)
Assets	Restituisce un'istanza di AssetManager per il pacchetto dell'applicazione. (Ereditato da ContextWrapper)
AttributionSource	Ottiene l'origine di attribuzione associata a questo contesto. (Ereditato da Context)
AttributionTag	L'attribuzione può essere usata in app complesse per separare logicamente parti dell'app. (Ereditato da Context)
BaseContext	(Ereditato da ContextWrapper)
CacheDir	Restituisce il percorso assoluto della directory della cache specifica dell'applicazione nel file system. (Ereditato da ContextWrapper)
Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
ClassLoader	Restituisce un caricatore di classi che è possibile usare per recuperare le classi in questo pacchetto. (Ereditato da ContextWrapper)
CodeCacheDir	Restituisce il percorso assoluto della directory della cache specifica dell'applicazione nel file system progettato per l'archiviazione del codice memorizzato nella cache. (Ereditato da ContextWrapper)
ContentResolver	Restituisce un'istanza di ContentResolver per il pacchetto dell'applicazione. (Ereditato da ContextWrapper)
DataDir	Restituisce il percorso assoluto della directory nel file system in cui vengono archiviati tutti i file privati appartenenti a questa app. Le app non devono usare direttamente questo percorso; devono usare invece getFilesDir() , getCacheDir() , getDir(String,int) o altre API di archiviazione in questa classe. Il percorso restituito può cambiare nel tempo se l'app chiamante viene spostata in un dispositivo di archiviazione adottato, quindi solo i percorsi relativi devono essere mantenuti. Non sono necessarie autorizzazioni aggiuntive per consentire all'app chiamante di leggere o scrivere file nel percorso restituito. Restituisce un file (Ereditato da ContextWrapper)
DeviceId	Ottiene l'ID dispositivo a cui è associato questo contesto. (Ereditato da Context)
Display	Ottiene la visualizzazione a cui è associato questo contesto. (Ereditato da Context)
ExternalCacheDir	Restituisce il percorso assoluto della directory nel file system esterno primario, che si trova in un punto in ExternalStorageDirectory cui l'applicazione può inserire i file della cache di cui è proprietario. (Ereditato da ContextWrapper)
FilesDir	Restituisce il percorso assoluto della directory nel file system in cui vengono archiviati i file creati con OpenFileOutput(String, FileCreationMode) . (Ereditato da ContextWrapper)
FillEventHistory	Ottiene gli eventi che si sono verificati dopo l'ultima `AutofillService#onFillRequest(FillRequest, android.os.CancellationSignal, FillCallback)` chiamata.
ForegroundServiceType	Se il servizio è diventato un servizio in primo piano chiamando startForeground(int,Notification) o startForeground(int,Notification,int), getForegroundServiceType() restituisce il tipo di servizio in primo piano corrente. (Ereditato da Service)
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
IsDeviceProtectedStorage	Indica se le API di archiviazione di questo contesto sono supportate dall'archiviazione protetta dal dispositivo. (Ereditato da ContextWrapper)
IsRestricted	Indica se il contesto è limitato. (Ereditato da Context)
IsUiContext	Restituisce `true` se il contesto è un contesto dell'interfaccia utente che può accedere a componenti dell'interfaccia utente come `WindowManager`, `android.view.LayoutInflater LayoutInflater` o `android.app.WallpaperManager WallpaperManager`. (Ereditato da Context)
JniIdentityHashCode	Ottiene il codice hash di identità assegnato a questo Java peer dal runtime di interoperabilità. (Ereditato da Object)
JniManagedPeerState	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
JniPeerMembers	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.
MainExecutor	Restituisce un oggetto `Executor` che eseguirà attività accodate nel thread principale associato a questo contesto. (Ereditato da Context)
MainLooper	Restituisce il Looper per il thread principale del processo corrente. (Ereditato da ContextWrapper)
NoBackupFilesDir	Restituisce il percorso assoluto della directory nel file system simile a FilesDir. (Ereditato da ContextWrapper)
ObbDir	Restituisce la directory di archiviazione esterna primaria in cui è possibile trovare i file OBB dell'applicazione (se presenti). (Ereditato da ContextWrapper)
OpPackageName	Restituisce il nome del pacchetto che deve essere usato per `android.app.AppOpsManager` le chiamate da questo contesto, in modo che la verifica dell'interfaccia utente di Gestione operazioni app funzioni con il nome. (Ereditato da Context)
PackageCodePath	Restituisce il percorso completo del pacchetto Android primario di questo contesto. (Ereditato da ContextWrapper)
PackageManager	Restituire l'istanza di PackageManager per trovare informazioni globali sul pacchetto. (Ereditato da ContextWrapper)
PackageName	Restituisce il nome del pacchetto dell'applicazione. (Ereditato da ContextWrapper)
PackageResourcePath	Restituisce il percorso completo del pacchetto Android primario di questo contesto. (Ereditato da ContextWrapper)
Params	Restituisce il set di parametri con cui è stato creato il contesto, se è stato creato tramite `#createContext(ContextParams)`. (Ereditato da Context)
PeerReference	Ottiene il riferimento all'oggetto JNI per questo peer Java. (Ereditato da Object)
Resources	Restituisce un'istanza resources per il pacchetto dell'applicazione. (Ereditato da ContextWrapper)
Theme	Restituisce l'oggetto Theme associato a questo contesto. (Ereditato da ContextWrapper)
ThresholdClass	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.
ThresholdType	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.
Wallpaper	(Ereditato da ContextWrapper)
WallpaperDesiredMinimumHeight	(Ereditato da ContextWrapper)
WallpaperDesiredMinimumWidth	(Ereditato da ContextWrapper)

Metodi

Nome	Descrizione
AttachBaseContext(Context)	Impostare il contesto di base per contextWrapper. (Ereditato da ContextWrapper)
BindIsolatedService(Intent, Context+BindServiceFlags, String, IExecutor, IServiceConnection)	Vedere bindIsolatedService(Intent,int,String,Executor,ServiceConnection) Call BindServiceFlags.of(long) per ottenere un oggetto BindServiceFlags. (Ereditato da Context)
BindIsolatedService(Intent, Int32, String, IExecutor, IServiceConnection)	La variazione di `#bindService` tale, nel caso specifico dei servizi isolati, consente al chiamante di generare più istanze di un servizio da una singola dichiarazione di componente. (Ereditato da Context)
BindService(Intent, Bind, IExecutor, IServiceConnection)	Uguale a quello dell'executor `#bindService(Intent, ServiceConnection, int) bindService(Intent, ServiceConnection, int)` per controllare i callback di ServiceConnection. (Ereditato da Context)
BindService(Intent, Context+BindServiceFlags, IExecutor, IServiceConnection)	Vedere bindService(Intent,int,Executor,ServiceConnection) Call BindServiceFlags.of(long) per ottenere un oggetto BindServiceFlags. (Ereditato da Context)
BindService(Intent, IServiceConnection, Bind)	Connettersi a un servizio dell'applicazione, creandolo, se necessario. (Ereditato da ContextWrapper)
BindService(Intent, IServiceConnection, Context+BindServiceFlags)	Vedere bindService(Intent,ServiceConnection,int) Call BindServiceFlags.of(long) per ottenere un oggetto BindServiceFlags. (Ereditato da Context)
BindServiceAsUser(Intent, IServiceConnection, Context+BindServiceFlags, UserHandle)	Vedere bindServiceAsUser(Intent,ServiceConnection,int,UserHandle) Call BindServiceFlags.of(long) per ottenere un oggetto BindServiceFlags. (Ereditato da Context)
BindServiceAsUser(Intent, IServiceConnection, Int32, UserHandle)	Esegue il binding a un servizio nello `user` stesso modo di `#bindService`. (Ereditato da Context)
CheckCallingOrSelfPermission(String)	Determinare se al processo chiamante di un IPC o è stata concessa un'autorizzazione specifica. (Ereditato da ContextWrapper)
CheckCallingOrSelfUriPermission(Uri, ActivityFlags)	Determinare se al processo chiamante di un IPC o è stata concessa l'autorizzazione per accedere a un URI specifico. (Ereditato da ContextWrapper)
CheckCallingOrSelfUriPermissions(IList<Uri>, Int32)	Determinare se al processo chiamante di un IPC <em>o a te</em> è stata concessa l'autorizzazione per accedere a un elenco di URI. (Ereditato da Context)
CheckCallingPermission(String)	Determinare se al processo chiamante di un IPC gestito è stata concessa un'autorizzazione specifica. (Ereditato da ContextWrapper)
CheckCallingUriPermission(Uri, ActivityFlags)	Determinare se al processo chiamante e all'ID utente è stata concessa l'autorizzazione per accedere a un URI specifico. (Ereditato da ContextWrapper)
CheckCallingUriPermissions(IList<Uri>, Int32)	Determinare se al processo chiamante e all'uid è stata concessa l'autorizzazione per accedere a un elenco di URI. (Ereditato da Context)
CheckContentUriPermissionFull(Uri, Int32, Int32, ActivityFlags)	Determinare se a un particolare processo e uid è stata concessa l'autorizzazione per accedere a un URI di contenuto specifico. (Ereditato da Context)
CheckPermission(String, Int32, Int32)	Determinare se l'autorizzazione specificata è consentita per un processo specifico e un ID utente in esecuzione nel sistema. (Ereditato da ContextWrapper)
CheckSelfPermission(String)	Determinare se è stata concessa un'autorizzazione specifica. (Ereditato da ContextWrapper)
CheckUriPermission(Uri, Int32, Int32, ActivityFlags)	Determinare se a un processo specifico e a un ID utente è stata concessa l'autorizzazione per accedere a un URI specifico. (Ereditato da ContextWrapper)
CheckUriPermission(Uri, String, String, Int32, Int32, ActivityFlags)	Controllare sia un URI che un'autorizzazione normale. (Ereditato da ContextWrapper)
CheckUriPermissions(IList<Uri>, Int32, Int32, Int32)	Determinare se a un determinato processo e uid è stata concessa l'autorizzazione per accedere a un elenco di URI. (Ereditato da Context)
ClearWallpaper()	Obsoleti. (Ereditato da ContextWrapper)
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Construct(JniObjectReference, JniObjectReferenceOptions)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
CreateAttributionContext(String)	Restituisce un nuovo oggetto Context per il contesto corrente ma l'attributo a un tag diverso. (Ereditato da Context)
CreateConfigurationContext(Configuration)	Restituisce un nuovo oggetto Context per il contesto corrente, ma le cui risorse vengono modificate in modo che corrispondano alla configurazione specificata. (Ereditato da ContextWrapper)
CreateContext(ContextParams)	Crea un contesto con proprietà e comportamenti specifici. (Ereditato da Context)
CreateContextForSplit(String)	Restituisce un nuovo oggetto Context per il nome di divisione specificato. Il nuovo contesto ha un oggetto ClassLoader e Resources che può accedere al codice/alle risorse della divisione e a tutte le relative dipendenze. Ogni chiamata a questo metodo restituisce una nuova istanza di un oggetto Context; Gli oggetti contesto non vengono condivisi, ma lo stato comune (ClassLoader, altre risorse per la stessa divisione) può essere piuttosto leggero. (Ereditato da ContextWrapper)
CreateDeviceContext(Int32)	Restituisce un nuovo `Context` oggetto dal contesto corrente, ma con l'associazione `deviceId`del dispositivo specificata da . (Ereditato da Context)
CreateDeviceProtectedStorageContext()	Restituisce un nuovo oggetto Context per il contesto corrente, ma le cui API di archiviazione sono supportate dall'archiviazione protetta dal dispositivo. Nei dispositivi con avvio diretto, i dati archiviati in questa posizione vengono crittografati con una chiave associata al dispositivo fisico ed è possibile accedervi immediatamente dopo l'avvio del dispositivo, sia prima che dopo l'autenticazione dell'utente con le proprie credenziali (ad esempio un modello di blocco o un PIN). Poiché i dati protetti dal dispositivo sono disponibili senza autenticazione utente, è consigliabile limitare attentamente i dati archiviati usando questo contesto. Ad esempio, l'archiviazione di token di autenticazione sensibili o password nell'area protetta dal dispositivo è fortemente sconsigliata. Se il dispositivo sottostante non ha la possibilità di archiviare dati protetti dal dispositivo e protetti da credenziali usando chiavi diverse, entrambe le aree di archiviazione saranno disponibili contemporaneamente. Rimangono come due percorsi di archiviazione distinti su disco e solo la finestra delle modifiche alla disponibilità. Ogni chiamata a questo metodo restituisce una nuova istanza di un oggetto Context; Gli oggetti contesto non vengono condivisi, ma lo stato comune (ClassLoader, altre risorse per la stessa configurazione) può essere quindi piuttosto leggero. Restituisce il contesto (Ereditato da ContextWrapper)
CreateDisplayContext(Display)	Restituisce un nuovo oggetto Context per l'oggetto Context corrente, ma le cui risorse vengono modificate in modo che corrispondano alle metriche del display specificato. (Ereditato da ContextWrapper)
CreatePackageContext(String, PackageContextFlags)	Restituisce un nuovo oggetto Context per il nome dell'applicazione specificato. (Ereditato da ContextWrapper)
CreateWindowContext(Display, Int32, Bundle)	Crea un oggetto `Context` per una finestra non`android.app.Activity activity` nell'oggetto specificato `Display`. (Ereditato da Context)
CreateWindowContext(Int32, Bundle)	Crea un contesto per una finestra non attività. (Ereditato da Context)
DatabaseList()	Restituisce una matrice di stringhe che denominano i database privati associati al pacchetto dell'applicazione del contesto. (Ereditato da ContextWrapper)
DeleteDatabase(String)	Eliminare una SQLiteDatabase privata esistente associata al pacchetto dell'applicazione di questo contesto. (Ereditato da ContextWrapper)
DeleteFile(String)	Eliminare il file privato specificato associato al pacchetto dell'applicazione context. (Ereditato da ContextWrapper)
DeleteSharedPreferences(String)	Eliminare un file di preferenze condivise esistente. (Ereditato da ContextWrapper)
Dispose()	Rilascia le risorse contenute in questo peer Java. (Ereditato da Object)
Dispose(Boolean)	Rilascia le risorse contenute in questo peer Java. (Ereditato da Object)
DisposeUnlessReferenced()	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
Dump(FileDescriptor, PrintWriter, String[])	Stampare lo stato del servizio nel flusso specificato. (Ereditato da Service)
EnforceCallingOrSelfPermission(String, String)	Se non si né il processo chiamante di un IPC gestito è stato concesso un'autorizzazione specifica, generare un'eccezione SecurityException. (Ereditato da ContextWrapper)
EnforceCallingOrSelfUriPermission(Uri, ActivityFlags, String)	Se al processo chiamante di un IPC o non è stata concessa l'autorizzazione per accedere a un URI specifico, generare SecurityException. (Ereditato da ContextWrapper)
EnforceCallingPermission(String, String)	Se al processo chiamante di un IPC che si sta gestendo non è stata concessa una determinata autorizzazione, generare un'eccezione SecurityException. (Ereditato da ContextWrapper)
EnforceCallingUriPermission(Uri, ActivityFlags, String)	Se al processo chiamante e all'ID utente non è stata concessa l'autorizzazione per accedere a un URI specifico, generare SecurityException. (Ereditato da ContextWrapper)
EnforcePermission(String, Int32, Int32, String)	Se l'autorizzazione specificata non è consentita per un processo specifico e un ID utente in esecuzione nel sistema, generare un'eccezione SecurityException. (Ereditato da ContextWrapper)
EnforceUriPermission(Uri, Int32, Int32, ActivityFlags, String)	Se a un processo specifico e a un ID utente non è stata concessa l'autorizzazione per accedere a un URI specifico, generare SecurityException. (Ereditato da ContextWrapper)
EnforceUriPermission(Uri, String, String, Int32, Int32, ActivityFlags, String)	Applicare sia un URI che un'autorizzazione normale. (Ereditato da ContextWrapper)
Equals(Object)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
FileList()	Restituisce una matrice di stringhe che denominano i file privati associati al pacchetto dell'applicazione context. (Ereditato da ContextWrapper)
GetColor(Int32)	Restituisce un colore associato a un ID risorsa specifico e a uno stile per il tema corrente. (Ereditato da Context)
GetColorStateList(Int32)	Restituisce un elenco di stati di colore associato a un ID risorsa specifico e stile per il tema corrente. (Ereditato da Context)
GetDatabasePath(String)	Restituisce il percorso assoluto nel file system in cui è archiviato un database creato con openOrCreateDatabase(String, int, CursorFactory). Il percorso restituito può cambiare nel tempo se l'app chiamante viene spostata in un dispositivo di archiviazione adottato, quindi solo i percorsi relativi devono essere mantenuti. (Ereditato da ContextWrapper)
GetDir(String, FileCreationMode)	Recuperare, creare, se necessario, una nuova directory in cui l'applicazione può inserire i propri file di dati personalizzati. (Ereditato da ContextWrapper)
GetDrawable(Int32)	Restituisce un oggetto disegnabile associato a un ID risorsa specifico e a uno stile per il tema corrente. (Ereditato da Context)
GetExternalCacheDirs()	Restituisce percorsi assoluti alle directory specifiche dell'applicazione in tutti i dispositivi di archiviazione esterni in cui l'applicazione può inserire i file della cache di cui è proprietario. (Ereditato da ContextWrapper)
GetExternalFilesDir(String)	Restituisce il percorso assoluto della directory nel file system esterno primario (che si trova in un punto qualsiasi di ExternalStorageDirectory) in cui l'applicazione può inserire file persistenti di cui è proprietario. (Ereditato da ContextWrapper)
GetExternalFilesDirs(String)	Restituisce percorsi assoluti alle directory specifiche dell'applicazione in tutti i dispositivi di archiviazione esterni in cui l'applicazione può inserire file persistenti di cui è proprietario. (Ereditato da ContextWrapper)
GetExternalMediaDirs()	Obsoleti. Restituisce percorsi assoluti alle directory specifiche dell'applicazione in tutti i dispositivi di archiviazione esterni in cui l'applicazione può inserire file multimediali. (Ereditato da ContextWrapper)
GetFileStreamPath(String)	Restituisce il percorso assoluto nel file system in cui è archiviato un file creato con OpenFileOutput(String, FileCreationMode) . (Ereditato da ContextWrapper)
GetHashCode()	Restituisce un valore di codice hash per l'oggetto . (Ereditato da Object)
GetObbDirs()	Restituisce percorsi assoluti alle directory specifiche dell'applicazione in tutti i dispositivi di archiviazione esterni in cui è possibile trovare i file OBB dell'applicazione (se presenti). (Ereditato da ContextWrapper)
GetSharedPreferences(String, FileCreationMode)	Recuperare e contenere il contenuto del file delle preferenze 'name', restituendo un oggetto SharedPreferences tramite il quale è possibile recuperare e modificare i relativi valori. (Ereditato da ContextWrapper)
GetString(Int32, Object[])	Restituisce una stringa localizzata dalla tabella di stringhe predefinita del pacchetto dell'applicazione. (Ereditato da Context)
GetString(Int32)	Restituisce una stringa localizzata dalla tabella di stringhe predefinita del pacchetto dell'applicazione. (Ereditato da Context)
GetSystemService(Class)	Restituire l'handle a un servizio a livello di sistema per classe. (Ereditato da Context)
GetSystemService(String)	Restituire l'handle a un servizio a livello di sistema in base al nome. (Ereditato da ContextWrapper)
GetSystemServiceName(Class)	Ottiene il nome del servizio a livello di sistema rappresentato dalla classe specificata. (Ereditato da ContextWrapper)
GetText(Int32)	Restituisce una stringa di tipo CharSequence localizzata dalla tabella di stringhe predefinita del pacchetto dell'applicazione. (Ereditato da Context)
GetTextFormatted(Int32)	Restituisce una stringa di tipo CharSequence localizzata dalla tabella di stringhe predefinita del pacchetto dell'applicazione. (Ereditato da Context)
GrantUriPermission(String, Uri, ActivityFlags)	Concedere l'autorizzazione per accedere a un URI specifico a un altro pacchetto, indipendentemente dal fatto che il pacchetto disponga dell'autorizzazione generale per accedere al provider di contenuti dell'URI. (Ereditato da ContextWrapper)
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
MoveDatabaseFrom(Context, String)	Spostare un file di database esistente dal contesto di archiviazione di origine specificato a questo contesto. Viene in genere usato per eseguire la migrazione dei dati tra posizioni di archiviazione dopo un aggiornamento, ad esempio la migrazione all'archiviazione protetta dal dispositivo. Il database deve essere chiuso prima di essere spostato. (Ereditato da ContextWrapper)
MoveSharedPreferencesFrom(Context, String)	Spostare un file di preferenze condivise esistente dal contesto di archiviazione di origine specificato a questo contesto. Viene in genere usato per eseguire la migrazione dei dati tra posizioni di archiviazione dopo un aggiornamento, ad esempio il passaggio all'archiviazione protetta dal dispositivo. (Ereditato da ContextWrapper)
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object)
ObtainStyledAttributes(IAttributeSet, Int32[], Int32, Int32)	Recuperare le informazioni sull'attributo con stile nel tema di questo contesto. (Ereditato da Context)
ObtainStyledAttributes(IAttributeSet, Int32[])	Recuperare le informazioni sull'attributo con stile nel tema di questo contesto. (Ereditato da Context)
ObtainStyledAttributes(Int32, Int32[])	Recuperare le informazioni sull'attributo con stile nel tema di questo contesto. (Ereditato da Context)
ObtainStyledAttributes(Int32[])	Recuperare le informazioni sull'attributo con stile nel tema di questo contesto. (Ereditato da Context)
OnBind(Intent)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.
OnConfigurationChanged(Configuration)	Chiamato dal sistema quando la configurazione del dispositivo cambia durante l'esecuzione del componente. (Ereditato da Service)
OnConnected()	Chiamato quando il sistema Android si connette al servizio.
OnCreate()	Chiamato dal sistema quando il servizio viene creato per la prima volta. (Ereditato da Service)
OnDestroy()	Chiamato dal sistema per notificare a un servizio che non viene più usato e viene rimosso. (Ereditato da Service)
OnDisconnected()	Chiamato quando il sistema Android si disconnette dal servizio.
OnFillRequest(FillRequest, CancellationSignal, FillCallback)	Chiamato dal sistema Android decidere se una schermata può essere riempita automaticamente dal servizio.
OnLowMemory()	Questo viene chiamato quando il sistema complessivo è in esecuzione insufficiente sulla memoria e i processi in esecuzione attivamente devono ridurre l'utilizzo della memoria. (Ereditato da Service)
OnRebind(Intent)	Chiamato quando i nuovi client sono connessi al servizio, dopo che in precedenza era stato informato che tutti i client erano stati disconnessi nel relativo onUnbind(Intent). (Ereditato da Service)
OnSavedDatasetsInfoRequest(ISavedDatasetsInfoCallback)	Chiamato dalle impostazioni di sistema per visualizzare informazioni sui set di dati salvati dall'utente in questo servizio.
OnSaveRequest(SaveRequest, SaveCallback)	Chiamato quando l'utente richiede al servizio di salvare il contenuto di una schermata.
OnSessionDestroyed(FillEventHistory)	Chiamato quando un contesto di riempimento automatico è terminato e la sessione di riempimento automatico è terminata.
OnStart(Intent, Int32)	Obsoleti. Questo metodo è stato deprecato nel livello API 15. (Ereditato da Service)
OnStartCommand(Intent, StartCommandFlags, Int32)	Chiamato dal sistema ogni volta che un client avvia il servizio in modo esplicito chiamando Context.startService(Intent), fornendo gli argomenti forniti e un token integer univoco che rappresenta la richiesta di avvio. (Ereditato da Service)
OnTaskRemoved(Intent)	Viene chiamato se il servizio è attualmente in esecuzione e l'utente ha rimosso un'attività proveniente dall'applicazione del servizio. (Ereditato da Service)
OnTimeout(Int32, ForegroundService)	Callback chiamato quando si è verificato il timeout di un particolare tipo di servizio in primo piano. (Ereditato da Service)
OnTimeout(Int32)	Callback chiamato al timeout per ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE. (Ereditato da Service)
OnTrimMemory(TrimMemory)	Chiamato quando il sistema operativo ha determinato che è un buon momento per un processo per ridurre la memoria non richiesta dal relativo processo. (Ereditato da Service)
OnUnbind(Intent)	Chiamato quando tutti i client sono disconnessi da una particolare interfaccia pubblicata dal servizio. (Ereditato da Service)
OpenFileInput(String)	Aprire un file privato associato al pacchetto dell'applicazione context per la lettura. (Ereditato da ContextWrapper)
OpenFileOutput(String, FileCreationMode)	Aprire un file privato associato al pacchetto dell'applicazione del contesto per la scrittura. (Ereditato da ContextWrapper)
OpenOrCreateDatabase(String, FileCreationMode, SQLiteDatabase+ICursorFactory, IDatabaseErrorHandler)	Aprire un nuovo SQLiteDatabase privato associato al pacchetto dell'applicazione del contesto. (Ereditato da ContextWrapper)
OpenOrCreateDatabase(String, FileCreationMode, SQLiteDatabase+ICursorFactory)	Aprire un nuovo SQLiteDatabase privato associato al pacchetto dell'applicazione del contesto. (Ereditato da ContextWrapper)
PeekWallpaper()	Obsoleti. (Ereditato da ContextWrapper)
RegisterComponentCallbacks(IComponentCallbacks)	Aggiungere un nuovo `ComponentCallbacks` oggetto all'applicazione di base del context, che verrà chiamato contemporaneamente ai metodi ComponentCallbacks di attività e ad altri componenti. (Ereditato da Context)
RegisterDeviceIdChangeListener(IExecutor, IIntConsumer)	Aggiunge un nuovo listener modificato dell'ID `Context`dispositivo a , che verrà chiamato quando l'associazione del dispositivo viene modificata dal sistema. (Ereditato da Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, ActivityFlags)	Obsoleti. Registrarsi per ricevere le trasmissioni delle finalità, con il ricevitore che facoltativamente viene esposto ad App istantanee. Per altre informazioni, vedere registerReceiver(BroadcastReceiver,IntentFilter). Per impostazione predefinita, Le app istantanee non possono interagire con i ricevitori in altre applicazioni, in questo modo è possibile esporre un ricevitore con cui Le app istantanee possono interagire. Per altre informazioni sulle trasmissioni finalità, vedere BroadcastReceiver. A partire da Build.VERSION_CODES. UPSIDE_DOWN_CAKE , il sistema può inserire le trasmissioni registrate nel contesto in una coda mentre l'app si trova nello stato memorizzato nella cache . Quando l'app lascia lo stato memorizzato nella cache, ad esempio la restituzione in primo piano, il sistema recapita tutte le trasmissioni in coda. Più istanze di determinate trasmissioni potrebbero essere unite in un'unica trasmissione. A partire da Build.VERSION_CODES. ICE_CREAM_SANDWICH , i ricevitori registrati con questo metodo rispetteranno correttamente l'oggetto Intent.setPackage(String) specificato per una trasmissione finalità. Prima di questo, verrebbe ignorato e recapitato a tutti i ricevitori registrati corrispondenti. Prestare attenzione se si usa questa opzione per la sicurezza. Ricevitore di parametri BroadcastReceiver: questo valore può essere null. (Ereditato da ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter, ReceiverFlags)	Registrarsi per ricevere le trasmissioni delle finalità, con il ricevitore che facoltativamente viene esposto ad App istantanee. Per altre informazioni, vedere registerReceiver(BroadcastReceiver,IntentFilter). Per impostazione predefinita, Le app istantanee non possono interagire con i ricevitori in altre applicazioni, in questo modo è possibile esporre un ricevitore con cui Le app istantanee possono interagire. Per altre informazioni sulle trasmissioni finalità, vedere BroadcastReceiver. A partire da Build.VERSION_CODES. UPSIDE_DOWN_CAKE , il sistema può inserire le trasmissioni registrate nel contesto in una coda mentre l'app si trova nello stato memorizzato nella cache . Quando l'app lascia lo stato memorizzato nella cache, ad esempio la restituzione in primo piano, il sistema recapita tutte le trasmissioni in coda. Più istanze di determinate trasmissioni potrebbero essere unite in un'unica trasmissione. A partire da Build.VERSION_CODES. ICE_CREAM_SANDWICH , i ricevitori registrati con questo metodo rispetteranno correttamente l'oggetto Intent.setPackage(String) specificato per una trasmissione finalità. Prima di questo, verrebbe ignorato e recapitato a tutti i ricevitori registrati corrispondenti. Prestare attenzione se si usa questa opzione per la sicurezza. Ricevitore di parametri BroadcastReceiver: BroadcastReceiver per gestire la trasmissione. Questo valore può essere null. (Ereditato da Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler, ActivityFlags)	Obsoleti. Eseguire la registrazione per ricevere le trasmissioni delle finalità, per l'esecuzione nel contesto dell'utilità di pianificazione . Per altre informazioni, vedere registerReceiver(BroadcastReceiver,IntentFilter,int) e registerReceiver(BroadcastReceiver,IntentFilter,String,Handler). Per altre informazioni sulle trasmissioni finalità, vedere BroadcastReceiver. A partire da Build.VERSION_CODES. UPSIDE_DOWN_CAKE , il sistema può inserire le trasmissioni registrate nel contesto in una coda mentre l'app si trova nello stato memorizzato nella cache . Quando l'app lascia lo stato memorizzato nella cache, ad esempio la restituzione in primo piano, il sistema recapita tutte le trasmissioni in coda. Più istanze di determinate trasmissioni potrebbero essere unite in un'unica trasmissione. A partire da Build.VERSION_CODES. ICE_CREAM_SANDWICH , i ricevitori registrati con questo metodo rispetteranno correttamente l'oggetto Intent.setPackage(String) specificato per una trasmissione finalità. Prima di questo, verrebbe ignorato e recapitato a tutti i ricevitori registrati corrispondenti. Prestare attenzione se si usa questa opzione per la sicurezza. Ricevitore di parametri BroadcastReceiver: questo valore può essere null. (Ereditato da ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler, ReceiverFlags)	Eseguire la registrazione per ricevere le trasmissioni delle finalità, per l'esecuzione nel contesto dell'utilità di pianificazione . Per altre informazioni, vedere registerReceiver(BroadcastReceiver,IntentFilter,int) e registerReceiver(BroadcastReceiver,IntentFilter,String,Handler). Per altre informazioni sulle trasmissioni finalità, vedere BroadcastReceiver. A partire da Build.VERSION_CODES. UPSIDE_DOWN_CAKE , il sistema può inserire le trasmissioni registrate nel contesto in una coda mentre l'app si trova nello stato memorizzato nella cache . Quando l'app lascia lo stato memorizzato nella cache, ad esempio la restituzione in primo piano, il sistema recapita tutte le trasmissioni in coda. Più istanze di determinate trasmissioni potrebbero essere unite in un'unica trasmissione. A partire da Build.VERSION_CODES. ICE_CREAM_SANDWICH , i ricevitori registrati con questo metodo rispetteranno correttamente l'oggetto Intent.setPackage(String) specificato per una trasmissione finalità. Prima di questo, verrebbe ignorato e recapitato a tutti i ricevitori registrati corrispondenti. Prestare attenzione se si usa questa opzione per la sicurezza. Ricevitore di parametri BroadcastReceiver: BroadcastReceiver per gestire la trasmissione. (Ereditato da Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler)	Eseguire la registrazione per ricevere le trasmissioni delle finalità, per l'esecuzione nel contesto di <var scheduler>/var<>. (Ereditato da ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter)	Registrare un broadcastReceiver da eseguire nel thread di attività principale. (Ereditato da ContextWrapper)
RemoveStickyBroadcast(Intent)	Obsoleti. (Ereditato da ContextWrapper)
RemoveStickyBroadcastAsUser(Intent, UserHandle)	Obsoleti. (Ereditato da ContextWrapper)
RevokeSelfPermissionOnKill(String)	Attiva la revoca asincrona di un'autorizzazione di runtime. (Ereditato da Context)
RevokeSelfPermissionsOnKill(ICollection<String>)	Attiva la revoca di una o più autorizzazioni per il pacchetto chiamante. (Ereditato da Context)
RevokeUriPermission(String, Uri, ActivityFlags)	Rimuovere le autorizzazioni per accedere a un URI del provider di contenuto specifico aggiunto in precedenza con grantUriPermission(String, Uri, int) per un pacchetto di destinazione specifico. L'URI specificato corrisponderà a tutti gli URI precedentemente concessi che corrispondono allo stesso percorso o a un sottopercorso dell'URI specificato. Ovvero revocando "content://foo/target" verranno revocati sia "content://foo/target" che "content://foo/target/sub", ma non "content://foo". Non rimuoverà le concessioni di prefisso esistenti a un livello superiore. A differenza di revokeUriPermission(Uri,int), questo metodo revoca solo le autorizzazioni concesse in modo esplicito tramite grantUriPermission(String, Uri, int) e solo per il pacchetto specificato. Eventuali concessioni corrispondenti eseguite tramite altri meccanismi (Appunti, avvio di attività, avvio del servizio e così via) non verranno rimossi. (Ereditato da ContextWrapper)
RevokeUriPermission(Uri, ActivityFlags)	Rimuovere tutte le autorizzazioni per accedere a un URI del provider di contenuti specifico aggiunto in precedenza con M:Android.Content.Context.GrantUriPermission(System.String,Android.Net.Uri,Android.Net.Uri). (Ereditato da ContextWrapper)
SendBroadcast(Intent, String, Bundle)	Trasmettere la finalità specificata a tutti gli interessati BroadcastReceivers, consentendo l'applicazione di un'autorizzazione facoltativa obbligatoria. (Ereditato da Context)
SendBroadcast(Intent, String)	Trasmettere la finalità specificata a tutti gli interessati BroadcastReceivers, consentendo l'applicazione di un'autorizzazione facoltativa obbligatoria. (Ereditato da ContextWrapper)
SendBroadcast(Intent)	Trasmettere la finalità specificata a tutti gli interessati BroadcastReceivers. (Ereditato da ContextWrapper)
SendBroadcastAsUser(Intent, UserHandle, String)	Versione di SendBroadcast(Intent, String) che consente di specificare l'utente a cui verrà inviata la trasmissione. (Ereditato da ContextWrapper)
SendBroadcastAsUser(Intent, UserHandle)	Versione di SendBroadcast(Intent) che consente di specificare l'utente a cui verrà inviata la trasmissione. (Ereditato da ContextWrapper)
SendBroadcastWithMultiplePermissions(Intent, String[])	Trasmettere la finalità specificata a tutti gli interessati BroadcastReceivers, consentendo l'applicazione di una matrice di autorizzazioni necessarie. (Ereditato da Context)
SendOrderedBroadcast(Intent, Int32, String, String, BroadcastReceiver, Handler, String, Bundle, Bundle)	Trasmette una finalità ai ricevitori interessati in ordine. (Ereditato da ContextWrapper)
SendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, Result, String, Bundle)	Versione di SendBroadcast(Intent) che consente di ricevere i dati dalla trasmissione. (Ereditato da ContextWrapper)
SendOrderedBroadcast(Intent, String, Bundle, BroadcastReceiver, Handler, Result, String, Bundle)	Versione di `#sendBroadcast(Intent)` che consente di ricevere i dati dalla trasmissione. (Ereditato da Context)
SendOrderedBroadcast(Intent, String, Bundle)	Trasmettere la finalità specificata a tutti i BroadcastReceiver interessati, consegnandoli uno alla volta per consentire a più ricevitori preferiti di utilizzare la trasmissione prima che venga recapitata a ricevitori meno preferiti. (Ereditato da Context)
SendOrderedBroadcast(Intent, String, String, BroadcastReceiver, Handler, Result, String, Bundle)	Versione di `#sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)` che consente di specificare l'app op per applicare restrizioni ai ricevitori a cui verrà inviata la trasmissione. (Ereditato da Context)
SendOrderedBroadcast(Intent, String)	Trasmettere la finalità specificata a tutti i BroadcastReceiver interessati, consegnandoli uno alla volta per consentire a più ricevitori preferiti di utilizzare la trasmissione prima che venga recapitata a ricevitori meno preferiti. Questa chiamata è asincrona; viene restituito immediatamente e si continuerà a essere in esecuzione mentre vengono eseguiti i ricevitori. Per altre informazioni sulle trasmissioni finalità, vedere BroadcastReceiver. (Ereditato da ContextWrapper)
SendOrderedBroadcastAsUser(Intent, UserHandle, String, BroadcastReceiver, Handler, Result, String, Bundle)	Versione di sendOrderedBroadcast(Intent,String,BroadcastReceiver,Handler,int,String,Bundle) che consente di specificare l'utente a cui verrà inviata la trasmissione. Questa opzione non è disponibile per le applicazioni non preinstallate nell'immagine di sistema. Per altre informazioni sulle trasmissioni finalità, vedere BroadcastReceiver. Richiede Android. Manifest.permission.INTERACT_ACROSS_USERS (Ereditato da ContextWrapper)
SendStickyBroadcast(Intent, Bundle)	Eseguire un oggetto `#sendBroadcast(Intent)` "permanente", ovvero l'intento che si sta inviando rimane intorno dopo il completamento della trasmissione, in modo che altri utenti possano recuperare rapidamente i dati tramite il valore restituito di `#registerReceiver(BroadcastReceiver, IntentFilter)`. (Ereditato da Context)
SendStickyBroadcast(Intent)	Obsoleti. Eseguire un oggetto `#sendBroadcast(Intent)` "permanente", ovvero l'intento che si sta inviando rimane intorno dopo il completamento della trasmissione, in modo che altri utenti possano recuperare rapidamente i dati tramite il valore restituito di `#registerReceiver(BroadcastReceiver, IntentFilter)`. (Ereditato da ContextWrapper)
SendStickyBroadcastAsUser(Intent, UserHandle)	Obsoleti. (Ereditato da ContextWrapper)
SendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, Result, String, Bundle)	Obsoleti. (Ereditato da ContextWrapper)
SendStickyOrderedBroadcastAsUser(Intent, UserHandle, BroadcastReceiver, Handler, Result, String, Bundle)	Obsoleti. (Ereditato da ContextWrapper)
SetForeground(Boolean)	Questo membro è deprecato. (Ereditato da Service)
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
SetTheme(Int32)	Impostare il tema di base per questo contesto. (Ereditato da ContextWrapper)
SetWallpaper(Bitmap)	Obsoleti. (Ereditato da ContextWrapper)
SetWallpaper(Stream)	Obsoleti. (Ereditato da ContextWrapper)
StartActivities(Intent[], Bundle)	Avviare più nuove attività. (Ereditato da ContextWrapper)
StartActivities(Intent[])	Uguale a StartActivities(Intent[], Bundle) senza opzioni specificate. (Ereditato da ContextWrapper)
StartActivity(Intent, Bundle)	Avviare una nuova attività. (Ereditato da ContextWrapper)
StartActivity(Intent)	Uguale a StartActivity(Intent, Bundle) senza opzioni specificate. (Ereditato da ContextWrapper)
StartActivity(Type)	Uguale a startActivity(Intent,Bundle) senza opzioni specificate. (Ereditato da Context)
StartForeground(Int32, Notification, ForegroundService)	Versione di overload di startForeground(int,Notification) con parametro foregroundServiceType aggiuntivo. (Ereditato da Service)
StartForeground(Int32, Notification)	Se il servizio viene avviato (in esecuzione tramite Context.startService(Intent),anche questo servizio viene eseguito in primo piano, fornendo la notifica in corso da visualizzare all'utente in questo stato. (Ereditato da Service)
StartForegroundService(Intent)	Analogamente a startService(Intent), ma con una promessa implicita che il servizio chiamerà startForeground(int, android.app.Notification) dopo l'avvio dell'esecuzione. Al servizio viene assegnata una quantità di tempo paragonabile all'intervallo ANR per eseguire questa operazione. In caso contrario, il sistema arresterà automaticamente il processo, nel qual caso viene registrata un'eccezione interna ForegroundServiceDidNotStartInTimeException nei dispositivi che eseguono la versione dell'SDK Build.VERSION_CODES. S o versione successiva. Nelle versioni precedenti di Android viene invece registrata un'eccezione interna RemoteServiceException con un messaggio corrispondente. A differenza dell'ordinario startService(Intent) , questo metodo può essere usato in qualsiasi momento, indipendentemente dal fatto che l'app che ospita il servizio sia in primo piano. Nota: a partire dalla versione dell'SDK Build.VERSION_CODES. S , app destinate alla versione dell'SDK Build.VERSION_CODES. S o versione successiva non possono avviare i servizi in primo piano in background. Per altri dettagli, vedi Modifiche al comportamento: app destinate ad Android 12. (Ereditato da ContextWrapper)
StartInstrumentation(ComponentName, String, Bundle)	Avviare l'esecuzione di una Instrumentation classe. (Ereditato da ContextWrapper)
StartIntentSender(IntentSender, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Come StartActivity(Intent, Bundle), ma per avviare un intentSender. (Ereditato da ContextWrapper)
StartIntentSender(IntentSender, Intent, ActivityFlags, ActivityFlags, Int32)	Uguale a startIntentSender(IntentSender,Intent,int,int,int,Bundle) senza opzioni specificate. (Ereditato da ContextWrapper)
StartService(Intent)	Richiedere l'avvio di un determinato servizio dell'applicazione. (Ereditato da ContextWrapper)
StopForeground(Boolean)	Questo metodo è stato deprecato nel livello API 33. (Ereditato da Service)
StopForeground(StopForegroundFlags)	Rimuovere questo servizio dallo stato in primo piano, consentendo di ucciderlo se è necessaria una quantità maggiore di memoria. (Ereditato da Service)
StopSelf()	Arrestare il servizio, se è stato avviato in precedenza. (Ereditato da Service)
StopSelf(Int32)	Versione precedente di stopSelfResult(int) che non restituisce un risultato. (Ereditato da Service)
StopSelfResult(Int32)	Arrestare il servizio se l'ora più recente in cui è stato avviato è stato startId. (Ereditato da Service)
StopService(Intent)	Richiedere l'arresto di un determinato servizio dell'applicazione. (Ereditato da ContextWrapper)
ToArray<T>()	Crea una matrice gestita da questo wrapper di matrice Java. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto . (Ereditato da Object)
UnbindService(IServiceConnection)	Disconnettersi da un servizio dell'applicazione. (Ereditato da ContextWrapper)
UnregisterComponentCallbacks(IComponentCallbacks)	Rimuovere un `ComponentCallbacks` oggetto registrato in precedenza con `#registerComponentCallbacks(ComponentCallbacks)`. (Ereditato da Context)
UnregisterDeviceIdChangeListener(IIntConsumer)	Rimuove un listener modificato dall'ID dispositivo dal contesto. (Ereditato da Context)
UnregisterFromRuntime()	Annulla la registrazione di questo Java peer dal runtime di interoperabilità. (Ereditato da Object)
UnregisterReceiver(BroadcastReceiver)	Annullare la registrazione di un broadcastReceiver registrato in precedenza. (Ereditato da ContextWrapper)
UpdateServiceGroup(IServiceConnection, Int32, Int32)	Per un servizio associato in precedenza a `#bindService` o a un metodo correlato, modificare il modo in cui il sistema gestisce il processo del servizio in relazione ad altri processi. (Ereditato da Context)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo<> una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo<> una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

Nome	Descrizione
IJavaPeerable.Disposed()	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
IJavaPeerable.Finalized()	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da JavaObject)
IJavaPeerable.UnregisterFromRuntime()	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico. (Ereditato da Service)

Metodi di estensione

Nome	Descrizione
GetJniTypeName(IJavaPeerable)	Ottiene il nome JNI del tipo dell'istanza `self`di .
JavaAs<TResult>(IJavaPeerable)	Provare a digitare `selfTResult`, verificando che la coercizione sia valida sul lato Java.
JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Un `AutofillService` è un servizio usato per riempire automaticamente il contenuto della schermata per conto di un determinato utente. Per altre informazioni sul riempimento automatico, vedere Framework di riempimento automatico.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Provare a digitare `selfTResult`, verificando che la coercizione sia valida sul lato Java.

Si applica a