Activity Classe

Definição

Namespace:: Android.App

Assembly:: Mono.Android.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Uma atividade é uma única coisa focada que o usuário pode fazer.

[Android.Runtime.Register("android/app/Activity", DoNotGenerateAcw=true)]
public class Activity : Android.Views.ContextThemeWrapper, Android.Content.IComponentCallbacks2, Android.Views.KeyEvent.ICallback, Android.Views.LayoutInflater.IFactory2, Android.Views.View.IOnCreateContextMenuListener, Android.Views.Window.ICallback, IDisposable

[<Android.Runtime.Register("android/app/Activity", DoNotGenerateAcw=true)>]
type Activity = class
    inherit ContextThemeWrapper
    interface IComponentCallbacks
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IComponentCallbacks2
    interface KeyEvent.ICallback
    interface LayoutInflater.IFactory
    interface LayoutInflater.IFactory2
    interface View.IOnCreateContextMenuListener
    interface Window.ICallback

Herança: Object

JavaObject

Object

Context

ContextWrapper

ContextThemeWrapper
Activity

Derivado: Android.Accounts.AccountAuthenticatorActivity

Android.App.ActivityGroup

Android.App.AliasActivity

Android.App.ExpandableListActivity

Android.App.ListActivity

Mais…

Atributos: RegisterAttribute

Implementações: IComponentCallbacks IComponentCallbacks2 IJavaObject KeyEvent.ICallback LayoutInflater.IFactory LayoutInflater.IFactory2 View.IOnCreateContextMenuListener Window.ICallback IJavaPeerable IDisposable

Comentários

Uma atividade é uma única coisa focada que o usuário pode fazer. Quase todas as atividades interagem com o usuário, portanto, a classe Atividade cuida da criação de uma janela para você na qual você pode colocar sua interface do usuário com setContentView(View). Embora as atividades sejam frequentemente apresentadas ao usuário como janelas de tela inteira, elas também podem ser usadas de outras maneiras: como janelas flutuantes (por meio de um tema com R.attr.windowIsFloating set), modo Multi-Window ou inserido em outras janelas. Há dois métodos que quase todas as subclasses de Atividade implementarão: onCreate(Bundle) é onde você inicializa sua atividade. Mais importante, aqui você geralmente chamará setContentView(int) com um recurso de layout definindo sua interface do usuário e usando findViewById(int) para recuperar os widgets nessa interface do usuário com os quais você precisa interagir programaticamente. onPause() é onde você lida com o usuário pausando a interação ativa com a atividade. Todas as alterações feitas pelo usuário devem ser confirmadas neste momento (geralmente no ContentProvider que contém os dados). Nesse estado, a atividade ainda está visível na tela. Para ser usado com Context.startActivity(), todas as classes de atividade devem ter uma declaração de atividade> correspondente <no AndroidManifest.xmldo pacote.

Tópicos abordados aqui: Fragments Activity Lifecycle Configuration Changes Starting Activities and Getting Results Saving Persistent State Permissions Process Lifecycle Developer Guides The Activity class is an important part of a application's overall lifecycle, and the way activities are launched and put together is a fundamental part of the platform's application model. Para obter uma perspectiva detalhada sobre a estrutura de um aplicativo Android e como as atividades se comportam, leia os guias de desenvolvedores de Conceitos Básicos e Tarefas do Aplicativo e Back Stack.

Você também pode encontrar uma discussão detalhada sobre como criar atividades no guia do desenvolvedor de atividades.

A subclasse FragmentActivity pode usar a classe Fragment para modular melhor seu código, criar interfaces de usuário mais sofisticadas para telas maiores e ajudar a dimensionar seu aplicativo entre telas pequenas e grandes.

Para obter mais informações sobre como usar fragmentos, leia o guia do desenvolvedor fragmentos.

As atividades no sistema são gerenciadas como pilhas de atividades. Quando uma nova atividade é iniciada, ela geralmente é colocada na parte superior da pilha atual e se torna a atividade em execução. A atividade anterior sempre permanece abaixo dela na pilha e não entrará em primeiro plano novamente até que a nova atividade seja encerrada. Pode haver uma ou várias pilhas de atividade visíveis na tela.

Uma atividade tem essencialmente quatro estados:

O diagrama a seguir mostra os caminhos de estado importantes de uma atividade. Os retângulos quadrados representam métodos de retorno de chamada que você pode implementar para executar operações quando a atividade se move entre estados. Os ovais coloridos são estados principais em que a atividade pode estar.

Há três loops principais que você pode estar interessado em monitorar dentro de sua atividade: todo o tempo de vida de uma atividade ocorre entre a primeira chamada para onCreate(Bundle) até uma única chamada final para onDestroy(). Uma atividade fará toda a configuração do estado "global" em onCreate() e liberará todos os recursos restantes no onDestroy(). Por exemplo, se ele tiver um thread em execução em segundo plano para baixar dados da rede, ele poderá criar esse thread em onCreate() e, em seguida, parar o thread no onDestroy(). O tempo de vida visível de uma atividade ocorre entre uma chamada para onStart() até uma chamada correspondente para onStop(). Durante esse tempo, o usuário pode ver a atividade na tela, embora possa não estar em primeiro plano e interagindo com o usuário. Entre esses dois métodos, você pode manter os recursos necessários para mostrar a atividade ao usuário. Por exemplo, você pode registrar um BroadcastReceiver no onStart() para monitorar alterações que afetam sua interface do usuário e cancelá-la no onStop() quando o usuário não vir mais o que você está exibindo. Os métodos onStart() e onStop() podem ser chamados várias vezes, à medida que a atividade se torna visível e oculta para o usuário. O tempo de vida em primeiro plano de uma atividade ocorre entre uma chamada para onResume() até uma chamada correspondente para onPause(). Durante esse tempo, a atividade fica visível, ativa e interagindo com o usuário. Uma atividade pode frequentemente ficar entre os estados retomados e pausados , por exemplo, quando o dispositivo entra em suspensão, quando um resultado de atividade é entregue, quando uma nova intenção é entregue , portanto, o código nesses métodos deve ser bastante leve. Todo o ciclo de vida de uma atividade é definido pelos seguintes métodos de atividade. Todos eles são ganchos que você pode substituir para fazer o trabalho apropriado quando a atividade muda de estado. Todas as atividades implementarão onCreate(Bundle) para realizar a configuração inicial; muitos também implementarão onPause() para confirmar alterações nos dados e preparar-se para pausar a interação com o usuário e onStop() para lidar com não estar mais visível na tela. Você sempre deve chamar sua superclasse ao implementar esses métodos.

Em geral, o movimento por meio do ciclo de vida de uma atividade tem esta aparência:

Sempre seguido por onStart(). Nenhum onStart() onRestart() Chamado depois que sua atividade foi interrompida, antes de ser iniciada novamente. Sempre seguido por onStart() No onStart() onStart() Called when the activity is becoming visible to the user. Seguido por onResume() se a atividade chegar ao primeiro plano ou onStop() se ela ficar oculta. Nenhum onResume() ou onStop() onResume() Chamado quando a atividade começará a interagir com o usuário. Neste ponto, sua atividade está na parte superior de sua pilha de atividades, com a entrada do usuário indo para ela. Sempre seguido por onPause(). No onPause() onPause() Called when the activity loses foreground state, is no longer focusable or before transition to stopped/hidden or destroyed state. A atividade ainda está visível para o usuário, portanto, é recomendável mantê-la visualmente ativa e continuar atualizando a interface do usuário. As implementações desse método devem ser muito rápidas porque a próxima atividade não será retomada até que esse método retorne. Seguido por onResume() se a atividade retornar à frente ou onStop() se ela se tornar invisível para o usuário. Pré-Build.VERSION_CODES. HONEYCOMB onResume() ou onStop() onStop() Chamado quando a atividade não está mais visível para o usuário. Isso pode acontecer porque uma nova atividade está sendo iniciada no topo, uma existente está sendo trazida na frente desta ou esta está sendo destruída. Normalmente, isso é usado para interromper animações e atualizar a interface do usuário, etc. Seguido por onRestart() se essa atividade estiver voltando a interagir com o usuário ou onDestroy() se essa atividade estiver desaparecendo. Sim onRestart() ou onDestroy() onDestroy() A chamada final que você recebe antes que sua atividade seja destruída. Isso pode acontecer porque a atividade está terminando (alguém chamado Activity.finish nela) ou porque o sistema está destruindo temporariamente essa instância da atividade para economizar espaço. Você pode distinguir entre esses dois cenários com o método Activity.isFinishing. Sim, nada anote a coluna "Killable" na tabela acima – para os métodos que são marcados como sendo killable, depois que esse método retorna o processo que hospeda a atividade pode ser morto pelo sistema a qualquer momento sem que outra linha de seu código seja executada. Por isso, você deve usar o método onPause() para gravar quaisquer dados persistentes (como edições de usuário) no armazenamento. Além disso, o método onSaveInstanceState(Bundle) é chamado antes de colocar a atividade em tal estado em segundo plano, permitindo que você salve qualquer estado de instância dinâmica em sua atividade no pacote fornecido, para ser recebido posteriormente em onCreate(Bundle) se a atividade precisar ser recriada. Consulte a seção Ciclo de Vida do Processo para obter mais informações sobre como o ciclo de vida de um processo está vinculado às atividades que ele está hospedando. Observe que é importante salvar dados persistentes em onPause() em vez de onSaveInstanceState(Bundle) porque este último não faz parte dos retornos de chamada do ciclo de vida, portanto, não será chamado em todas as situações, conforme descrito em sua documentação.

Lembre-se de que essa semântica mudará ligeiramente entre aplicativos direcionados a plataformas que começam com Build.VERSION_CODES. HONEYCOMB vs. aqueles direcionados a plataformas anteriores. A partir do Honeycomb, um aplicativo não está no estado killable até que seu onStop() tenha retornado. Isso afeta quando onSaveInstanceState(Bundle) pode ser chamado (pode ser chamado com segurança após onPause()) e permite que um aplicativo aguarde com segurança até onStop() salvar o estado persistente.

Para aplicativos direcionados a plataformas que começam com Build.VERSION_CODES. P onSaveInstanceState(Bundle) sempre será chamado após onStop(), portanto, um aplicativo pode executar transações de fragmento com segurança no onStop() e poderá salvar o estado persistente mais tarde.

Para os métodos que não são marcados como killable, o processo da atividade não será eliminado pelo sistema a partir do momento em que o método for chamado e continuado após o retorno. Portanto, uma atividade está no estado killable, por exemplo, entre depois de onStop() até o início de onResume(). Tenha em mente que, sob extrema pressão de memória, o sistema pode acabar com o processo do aplicativo a qualquer momento.

Se a configuração do dispositivo (conforme definido pela classe Resources.Configuration) for alterada, qualquer coisa que exiba uma interface do usuário precisará ser atualizada para corresponder a essa configuração. Como a Atividade é o principal mecanismo para interagir com o usuário, ela inclui suporte especial para lidar com alterações de configuração.

A menos que você especifique o contrário, uma alteração de configuração (como uma alteração na orientação da tela, idioma, dispositivos de entrada etc.) fará com que sua atividade atual seja destruída, passando pelo processo de ciclo de vida de atividade normal de onPause(), onStop() e onDestroy() conforme apropriado. Se a atividade estiver em primeiro plano ou visível para o usuário, uma vez que onDestroy() for chamado nessa instância, uma nova instância da atividade será criada, com o que salvouInstanceState que a instância anterior havia gerado de onSaveInstanceState(Bundle).

Isso é feito porque qualquer recurso de aplicativo, incluindo arquivos de layout, pode ser alterado com base em qualquer valor de configuração. Portanto, a única maneira segura de lidar com uma alteração de configuração é recuperar todos os recursos, incluindo layouts, desenháveis e cadeias de caracteres. Como as atividades já devem saber como salvar seu estado e recriar-se desse estado, essa é uma maneira conveniente de fazer com que uma atividade seja reiniciada com uma nova configuração.

Em alguns casos especiais, talvez você queira ignorar a reinicialização da atividade com base em um ou mais tipos de alterações de configuração. Isso é feito com o atributo android:configChanges em seu manifesto. Para qualquer tipo de alteração de configuração que você diz que manipula lá, você receberá uma chamada para o método onConfigurationChanged(Configuration) da atividade atual em vez de ser reiniciado. Se uma alteração de configuração envolver qualquer uma que você não manipule, no entanto, a atividade ainda será reiniciada e onConfigurationChanged(Configuration) não será chamada.

O método startActivity(Intent) é usado para iniciar uma nova atividade, que será colocada na parte superior da pilha de atividades. Ele usa um único argumento, uma Intenção, que descreve a atividade a ser executada.

Às vezes, você deseja obter um resultado de volta de uma atividade quando ela termina. Por exemplo, você pode iniciar uma atividade que permite que o usuário escolha uma pessoa em uma lista de contatos; quando termina, retorna a pessoa que foi selecionada. Para fazer isso, você chama a versão android.app.Activity.startActivityForResult(Intent,int) com um segundo parâmetro inteiro identificando a chamada. O resultado será retornado por meio do método onActivityResult(int, int, Intent).

Quando uma atividade é encerrada, ela pode chamar setResult(int) para retornar dados para seu pai. Ele sempre deve fornecer um código de resultado, que pode ser os resultados padrão RESULT_CANCELED, RESULT_OK ou quaisquer valores personalizados a partir de RESULT_FIRST_USER. Além disso, ele pode, opcionalmente, retornar uma intenção que contenha quaisquer dados adicionais desejados. Todas essas informações são exibidas novamente em Activity.onActivityResult() pai, juntamente com o identificador inteiro fornecido originalmente.

Se uma atividade filho falhar por qualquer motivo (como falha), a atividade pai receberá um resultado com o código RESULT_CANCELED.

Geralmente, há dois tipos de estado persistente com os quais uma atividade lidará: dados compartilhados semelhantes a documentos (normalmente armazenados em um banco de dados SQLite usando um provedor de conteúdo) e estado interno, como preferências do usuário.

Para dados do provedor de conteúdo, sugerimos que as atividades usem um modelo de usuário "editar no local". Ou seja, todas as edições feitas por um usuário são efetivamente feitas imediatamente sem a necessidade de uma etapa de confirmação adicional. O suporte a esse modelo geralmente é uma questão simples das duas regras a seguir:

Ao criar um novo documento, a entrada ou o arquivo de banco de dados de backup para ele é criado imediatamente. Por exemplo, se o usuário optar por escrever um novo email, uma nova entrada para esse email será criada assim que eles começarem a inserir dados, de modo que, se eles forem para qualquer outra atividade depois desse ponto, esse email agora aparecerá na lista de rascunhos.

Quando o método onPause() de uma atividade é chamado, ele deve se comprometer com o provedor de conteúdo de backup ou arquivar todas as alterações feitas pelo usuário. Isso garante que essas alterações sejam vistas por qualquer outra atividade que esteja prestes a ser executada. Você provavelmente desejará confirmar seus dados de forma ainda mais agressiva em momentos-chave durante o ciclo de vida da atividade: por exemplo, antes de iniciar uma nova atividade, antes de terminar sua própria atividade, quando o usuário alterna entre campos de entrada etc.

Esse modelo foi projetado para evitar a perda de dados quando um usuário está navegando entre atividades e permite que o sistema encerre com segurança uma atividade (porque os recursos do sistema são necessários em outro lugar) a qualquer momento depois de ter sido interrompido (ou pausado em versões da plataforma antes de Build.VERSION_CODES. FAVO DE MEL). Observe que isso implica que o usuário pressionando DE VOLTA de sua atividade não significa "cancelar" – significa deixar a atividade com seu conteúdo atual salvo. O cancelamento de edições em uma atividade deve ser fornecido por meio de algum outro mecanismo, como uma opção explícita de "reverter" ou "desfazer".

Consulte o pacote de conteúdo para obter mais informações sobre provedores de conteúdo. Esses são um aspecto fundamental de como diferentes atividades invocam e propagam dados entre si.

A classe Atividade também fornece uma API para gerenciar o estado persistente interno associado a uma atividade. Isso pode ser usado, por exemplo, para lembrar a exibição inicial preferencial do usuário em um calendário (modo de exibição de dia ou semana) ou a home page padrão do usuário em um navegador da Web.

O estado persistente da atividade é gerenciado com o método getPreferences(int), permitindo que você recupere e modifique um conjunto de pares nome/valor associados à atividade. Para usar preferências compartilhadas entre vários componentes do aplicativo (atividades, receptores, serviços, provedores), você pode usar o método Context.getSharedPreferences() subjacente para recuperar um objeto de preferências armazenado em um nome específico. (Observe que não é possível compartilhar dados de configurações entre pacotes de aplicativos , pois você precisará de um provedor de conteúdo.)

Aqui está um trecho de uma atividade de calendário que armazena o modo de exibição preferencial do usuário em suas configurações persistentes:

A capacidade de iniciar uma atividade específica pode ser imposta quando ela é declarada na marca de atividade> do <manifesto. Ao fazer isso, outros aplicativos precisarão declarar um elemento de permissão> de uso correspondente <em seu próprio manifesto para poder iniciar essa atividade. Ao iniciar uma atividade, você pode definir Intent.FLAG_GRANT_READ_URI_PERMISSION e/ou Intent.FLAG_GRANT_WRITE_URI_PERMISSION na Intenção. Isso concederá à Atividade acesso às URIs específicas na Intenção. O acesso permanecerá até que a Atividade seja concluída (permanecerá em todo o processo de hospedagem sendo morto e outra destruição temporária). A partir de Build.VERSION_CODES. GINGERBREAD, se a Atividade já tiver sido criada e uma nova Intenção estiver sendo entregue ao onNewIntent(Intent), quaisquer permissões de URI recém-concedidas serão adicionadas às existentes que ela contém. Consulte o documento segurança e permissões para obter mais informações sobre permissões e segurança em geral. Ciclo de vida do processo O sistema Android tenta manter um processo de aplicativo por todo o tempo possível, mas eventualmente precisará remover processos antigos quando a memória for baixa. Conforme descrito no Ciclo de Vida da Atividade, a decisão sobre qual processo remover está intimamente ligada ao estado da interação do usuário com ele. Em geral, há quatro estados em que um processo pode ser baseado nas atividades em execução nele, listadas aqui em ordem de importância. O sistema eliminará processos menos importantes (os últimos) antes de recorrer a processos mais importantes (os primeiros). A atividade de primeiro plano (a atividade na parte superior da tela com a qual o usuário está interagindo atualmente) é considerada a mais importante. Seu processo só será encerrado como um último recurso, se ele usar mais memória do que está disponível no dispositivo. Geralmente, neste ponto, o dispositivo atingiu um estado de paginação de memória, portanto, isso é necessário para manter a interface do usuário responsiva. Uma atividade visível (uma atividade visível para o usuário, mas não em primeiro plano, como uma sentada atrás de uma caixa de diálogo em primeiro plano ou ao lado de outras atividades no modo de várias janelas) é considerada extremamente importante e não será eliminada, a menos que seja necessário manter a atividade em primeiro plano em execução. Uma atividade em segundo plano (uma atividade que não é visível para o usuário e foi interrompida) não é mais crítica, portanto, o sistema pode encerrar com segurança seu processo para recuperar a memória para outros processos visíveis ou em primeiro plano. Se seu processo precisar ser encerrado, quando o usuário navegar de volta para a atividade (tornando-a visível na tela novamente), seu método onCreate(Bundle) será chamado com o savedInstanceState fornecido anteriormente em onSaveInstanceState(Bundle) para que ele possa reiniciar-se no mesmo estado que o usuário deixou pela última vez. Um processo vazio é aquele que não hospeda atividades ou outros componentes do aplicativo (como classes Service ou BroadcastReceiver). Eles são mortos muito rapidamente pelo sistema à medida que a memória se torna baixa. Por esse motivo, qualquer operação em segundo plano que você faça fora de uma atividade deve ser executada no contexto de uma atividade BroadcastReceiver ou Service para garantir que o sistema saiba que precisa manter seu processo por perto. Às vezes, uma atividade pode precisar fazer uma operação de execução longa que exista independentemente do próprio ciclo de vida da atividade. Um exemplo pode ser um aplicativo de câmera que permite carregar uma imagem em um site. O upload pode levar muito tempo e o aplicativo deve permitir que o usuário deixe o aplicativo enquanto ele está em execução. Para fazer isso, sua Atividade deve iniciar um serviço no qual o upload ocorre. Isso permite que o sistema priorize corretamente o processo (considerando que ele é mais importante do que outros aplicativos não visíveis) durante o upload, independentemente de a atividade original ser pausada, interrompida ou concluída.

Referência do Android para android.app.Activity.

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

Construtores

Nome	Description
Activity()
Activity(IntPtr, JniHandleOwnership)	Inicializa uma representação gerenciada de um objeto de interface nativa Java existente.

Campos

Nome	Description
AccessibilityService	Use com `#getSystemService(String)` para recuperar um `android.view.accessibility.AccessibilityManager` para fornecer ao usuário comentários sobre eventos de interface do usuário por meio dos ouvintes de eventos registrados. (Herdado de Context)
AccountService	Use com `#getSystemService(String)` para recuperar um `android.accounts.AccountManager` para receber intenções em um momento de sua escolha. (Herdado de Context)
ActivityService	Use com `#getSystemService(String)` para recuperar um `android.app.ActivityManager` para interagir com o estado do sistema global. (Herdado de Context)
AdvancedProtectionService	Usar com `#getSystemService(String)` para recuperar um `android.security.advancedprotection.AdvancedProtectionManager` (Herdado de Context)
AlarmService	Use com `#getSystemService(String)` para recuperar um `android.app.AlarmManager` para receber intenções em um momento de sua escolha. (Herdado de Context)
AppFunctionService	Use com `#getSystemService(String)` para recuperar um `AppFunctionManager` para executar funções de aplicativo. (Herdado de Context)
AppInteractionService	Use com `#getSystemService(String)` para recuperar um `android.app.AppInteractionManager` para gerenciar interações de aplicativo. (Herdado de Context)
AppOpsService	Use com `#getSystemService(String)` para recuperar um `android.app.AppOpsManager` para rastrear operações de aplicativo no dispositivo. (Herdado de Context)
AppSearchService	Use com `#getSystemService(String)` para recuperar um `android.app.appsearch.AppSearchManager` para indexação e consulta de dados de aplicativo gerenciados pelo sistema. (Herdado de Context)
AppwidgetService	Use com `#getSystemService(String)` para recuperar um `android.appwidget.AppWidgetManager` para acessar AppWidgets. (Herdado de Context)
AudioService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.media.AudioManager` o gerenciamento de volume, modos de toque e roteamento de áudio. (Herdado de Context)
AuthenticationPolicyService	Use com `#getSystemService(String)` para recuperar um `android.security.authenticationpolicy.AuthenticationPolicyManager`. (Herdado de Context)
AutofillService	Use com `#getSystemService(String)` para recuperar um `android.view.autofill.AutofillManager`. (Herdado de Context)
BatteryService	Use com `#getSystemService(String)` para recuperar um `android.os.BatteryManager` para gerenciar o estado da bateria. (Herdado de Context)
BindAllowActivityStarts	Obsoleto. Sinalizador para `#bindService`: se a associação de um aplicativo estiver visível, o serviço associado poderá iniciar uma atividade em segundo plano. (Herdado de Context)
BindExternalServiceLong	Funciona da mesma maneira `#BIND_EXTERNAL_SERVICE`que , mas é definido como um `long` valor compatível `BindServiceFlags`com . (Herdado de Context)
BindNotPerceptible	Obsoleto. Sinalizador para `#bindService`: se a associação de um aplicativo visível ou perceptível pelo usuário, reduza a importância do serviço de destino para abaixo do nível perceptível. (Herdado de Context)
BindPackageIsolatedProcess	Obsoleto. Sinalizador para `#bindIsolatedService`: associar o serviço a um processo isolado compartilhado, mas somente com outros serviços isolados do mesmo pacote que declaram o mesmo nome do processo. (Herdado de Context)
BindSharedIsolatedProcess	Obsoleto. Sinalizador para `#bindIsolatedService`: associar o serviço a um processo isolado compartilhado. (Herdado de Context)
BiometricService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.hardware.biometrics.BiometricManager` autenticação biométrica e pin/padrão/senha. (Herdado de Context)
BlobStoreService	Use com `#getSystemService(String)` para recuperar um `android.app.blob.BlobStoreManager` para contribuir e acessar blobs de dados do repositório de blobs mantido pelo sistema. (Herdado de Context)
BluetoothService	Use com `#getSystemService(String)` para recuperar um `android.bluetooth.BluetoothManager` para usar Bluetooth. (Herdado de Context)
BugreportService	Serviço para capturar um relatório de bugs. (Herdado de Context)
CameraService	Use com `#getSystemService(String)` para recuperar um `android.hardware.camera2.CameraManager` para interagir com dispositivos de câmera. (Herdado de Context)
CaptioningService	Use com `#getSystemService(String)` para recuperar uma `android.view.accessibility.CaptioningManager` para obter propriedades de legendagem e escutar alterações nas preferências de legendagem. (Herdado de Context)
CarrierConfigService	Use com `#getSystemService(String)` para recuperar um `android.telephony.CarrierConfigManager` para ler valores de configuração da operadora. (Herdado de Context)
ChooserService	Use com `#getSystemService(String)` para recuperar um `android.service.chooser.ChooserManager`. (Herdado de Context)
ClipboardService	Use com `#getSystemService(String)` para recuperar um `android.content.ClipboardManager` para acessar e modificar o conteúdo da área de transferência global. (Herdado de Context)
CompanionDeviceService	Use com `#getSystemService(String)` para recuperar um `android.companion.CompanionDeviceManager` para gerenciar dispositivos complementares (Herdado de Context)
ConnectivityDiagnosticsService	Use com `#getSystemService(String)` para recuperar um `android.net.ConnectivityDiagnosticsManager` para executar o diagnóstico de conectividade de rede, bem como para receber informações de conectividade de rede do sistema. (Herdado de Context)
ConnectivityService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.net.ConnectivityManager` o gerenciamento de conexões de rede. (Herdado de Context)
ConsumerIrService	Use com `#getSystemService(String)` para recuperar um `android.hardware.ConsumerIrManager` sinal infravermelho para transmissão do dispositivo. (Herdado de Context)
ContactKeysService	Use com `#getSystemService(String)` para recuperar uma `E2eeContactKeysManager` chave de contato de gerenciamento. (Herdado de Context)
ContentRestrictionService	Use com `#getSystemService(String)` para recuperar um `android.app.contentsafety.ContentSafetyManager`. (Herdado de Context)
CredentialService	Use com `#getSystemService(String)` para recuperar um `android.credentials.CredentialManager` para autenticar um usuário em seu aplicativo. (Herdado de Context)
CrossProfileAppsService	Use com `#getSystemService(String)` para recuperar uma `android.content.pm.CrossProfileApps` para operações de perfil cruzado. (Herdado de Context)
DeviceIdDefault	A ID do dispositivo padrão, que é a ID do dispositivo primário (não virtual). (Herdado de Context)
DeviceIdInvalid	ID do dispositivo inválida. (Herdado de Context)
DeviceLockService	Use com `#getSystemService(String)` para recuperar um `android.devicelock.DeviceLockManager`. (Herdado de Context)
DevicePolicyService	Use com `#getSystemService(String)` para recuperar um `android.app.admin.DevicePolicyManager` para trabalhar com o gerenciamento global de políticas de dispositivo. (Herdado de Context)
DisplayHashService	Use com `#getSystemService(String)` o acesso `android.view.displayhash.DisplayHashManager` para manipular hashes de exibição. (Herdado de Context)
DisplayService	Use com `#getSystemService(String)` para recuperar um `android.hardware.display.DisplayManager` para interagir com dispositivos de exibição. (Herdado de Context)
DomainVerificationService	Use com `#getSystemService(String)` o acesso `android.content.pm.verify.domain.DomainVerificationManager` para recuperar a aprovação e o estado do usuário para domínios da Web declarados. (Herdado de Context)
DownloadService	Use com `#getSystemService(String)` para recuperar um `android.app.DownloadManager` para solicitar downloads HTTP. (Herdado de Context)
DropboxService	Use com `#getSystemService(String)` para recuperar uma `android.os.DropBoxManager` instância para registrar logs de diagnóstico. (Herdado de Context)
EuiccService	Use com `#getSystemService(String)` para recuperar um `android.telephony.euicc.EuiccManager` para gerenciar o dispositivo eUICC (SIM inserido). (Herdado de Context)
FileIntegrityService	Use com `#getSystemService(String)` para recuperar um `android.security.FileIntegrityManager`. (Herdado de Context)
FileService	Use com para recuperar um `android.os.storage.FileManager` para lidar com `#getSystemService(String)` operações de arquivo. (Herdado de Context)
FingerprintService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.hardware.fingerprint.FingerprintManager` o gerenciamento de impressões digitais. (Herdado de Context)
FullscreenModeRequestEnter	Obsoleto. Tipo de solicitação de `#requestFullscreenMode(int, OutcomeReceiver)`, para solicitar entrar no modo de tela inteira do modo de várias janelas.
FullscreenModeRequestExit	Obsoleto. Tipo de solicitação de `#requestFullscreenMode(int, OutcomeReceiver)`, para solicitar a saída do modo de tela inteira solicitado e restaurar para o modo de várias janelas anteriores.
GameService	Use com `#getSystemService(String)` para recuperar um `GameManager`. (Herdado de Context)
GrammaticalInflectionService	Use com `#getSystemService(String)` para recuperar um `GrammaticalInflectionManager`. (Herdado de Context)
HardwarePropertiesService	Use com `#getSystemService(String)` para recuperar um `android.os.HardwarePropertiesManager` para acessar o serviço de propriedades de hardware. (Herdado de Context)
HealthconnectService	Use com `#getSystemService(String)` para recuperar um `android.health.connect.HealthConnectManager`. (Herdado de Context)
HidService	Use com `#getSystemService(String)` para recuperar um `android.hardware.hid.HidManager` para interagir com dispositivos HID. (Herdado de Context)
InputMethodService	Use com `#getSystemService(String)` para recuperar um `android.view.inputmethod.InputMethodManager` para acessar métodos de entrada. (Herdado de Context)
InputService	Use com `#getSystemService(String)` para recuperar um `android.hardware.input.InputManager` para interagir com dispositivos de entrada. (Herdado de Context)
IpsecService	Use com `#getSystemService(String)` para recuperar um `android.net.IpSecManager` para criptografar soquetes ou redes com IPSec. (Herdado de Context)
JobSchedulerService	Use com `#getSystemService(String)` para recuperar uma `android.app.job.JobScheduler` instância para gerenciar tarefas ocasionais em segundo plano. (Herdado de Context)
KeychainService	Use com `#getSystemService(String)` para recuperar um `android.security.KeyChainManager` para gerenciar certificados e concessões do KeyChain. (Herdado de Context)
KeyguardService	Use com `#getSystemService(String)` para recuperar um `android.app.KeyguardManager` para controlar o keyguard. (Herdado de Context)
KeystoreService	Use com `#getSystemService(String)` para recuperar um `android.security.keystore.KeyStoreManager` para acessar funções de Repositório de Chaves do Android. (Herdado de Context)
LauncherAppsService	Use com `#getSystemService(String)` para recuperar um `android.content.pm.LauncherApps` para consultar e monitorar aplicativos inicializáveis entre perfis de um usuário. (Herdado de Context)
LayoutInflaterService	Use com `#getSystemService(String)` para recuperar um `android.view.LayoutInflater` para inflar recursos de layout neste contexto. (Herdado de Context)
LocaleService	Use com `#getSystemService(String)` para recuperar um `android.app.LocaleManager`. (Herdado de Context)
LocationService	Use com `#getSystemService(String)` para recuperar um `android.location.LocationManager` para controlar as atualizações de localização. (Herdado de Context)
MediaCommunicationService	Usar com `#getSystemService(String)` para recuperar um `android.media.MediaCommunicationManager` para gerenciar `android.media.MediaSession2`. (Herdado de Context)
MediaMetricsService	Use com `#getSystemService(String)` para recuperar um `android.media.metrics.MediaMetricsManager` para interagir com as métricas de mídia no dispositivo. (Herdado de Context)
MediaProjectionService	Use com `#getSystemService(String)` para recuperar uma `android.media.projection.MediaProjectionManager` instância para gerenciar sessões de projeção de mídia. (Herdado de Context)
MediaQualityService	Use com `#getSystemService(String)` para recuperar um `android.media.quality.MediaQualityManager` parâmetro de API de áudio e imagem padronizado. (Herdado de Context)
MediaRouterService	Use com `#getSystemService` para recuperar um `android.media.MediaRouter` para controlar e gerenciar o roteamento de mídia. (Herdado de Context)
MediaSessionService	Use com `#getSystemService(String)` para recuperar um `android.media.session.MediaSessionManager` para gerenciar sessões de mídia. (Herdado de Context)
MemoryBudgetService	Use com `#getSystemService(String)` para recuperar um `android.app.MemoryBudgetManager` para monitorar os orçamentos de memória. (Herdado de Context)
MidiService	Use com `#getSystemService(String)` para recuperar um `android.media.midi.MidiManager` para acessar o serviço MIDI. (Herdado de Context)
MultisensoryManagerService	Use com `#getSystemService(String)` para recuperar o serviço que reproduz comentários multisssensortivos. (Herdado de Context)
NetworkStatsService	Use com `#getSystemService(String)` para recuperar um `android.app.usage.NetworkStatsManager` para consultar estatísticas de uso de rede. (Herdado de Context)
NfcService	Use com `#getSystemService(String)` para recuperar um `android.nfc.NfcManager` para usar NFC. (Herdado de Context)
NotificationService	Use com `#getSystemService(String)` para recuperar um `android.app.NotificationManager` para informar o usuário sobre eventos em segundo plano. (Herdado de Context)
NpuService	Use com `#getSystemService(String)` para recuperar um `android.npumanager.NpuManager`. (Herdado de Context)
NsdService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.net.nsd.NsdManager` o gerenciamento da descoberta do serviço de rede (Herdado de Context)
OverlayService	Use com `#getSystemService(String)` para recuperar um `android.content.om.OverlayManager` para gerenciar pacotes de sobreposição. (Herdado de Context)
OverrideTransitionClose	Obsoleto. Tipo de solicitação ou `#overrideActivityTransition(int, int, int)#overrideActivityTransition(int, int, int, int)`, para substituir a transição de fechamento.
OverrideTransitionOpen	Obsoleto. Tipo de solicitação ou `#overrideActivityTransition(int, int, int)#overrideActivityTransition(int, int, int, int)`, para substituir a transição de abertura.
PccSandboxService	Use com `#getSystemService(String)` para recuperar um `android.app.privatecompute.PccSandboxManager`. (Herdado de Context)
PeopleService	Use com `#getSystemService(String)` para acessar uma `PeopleManager` interação com suas conversas publicadas. (Herdado de Context)
PerformanceHintService	Use com `#getSystemService(String)` para recuperar um `android.os.PerformanceHintManager` para acessar o serviço de sugestão de desempenho. (Herdado de Context)
PersistentDataBlockService	Use com `#getSystemService(String)` para recuperar uma `android.service.persistentdata.PersistentDataBlockManager` instância para interagir com um dispositivo de armazenamento que reside em redefinições de fábrica. (Herdado de Context)
PowerService	Use com `#getSystemService(String)` para recuperar um `android.os.PowerManager` para controlar o gerenciamento de energia, incluindo "bloqueios de ativação", que permitem manter o dispositivo ligado enquanto você está executando tarefas longas. (Herdado de Context)
PrintService	`android.print.PrintManager` para imprimir e gerenciar impressoras e imprimir tarefas. (Herdado de Context)
ProfilingService	Use com `#getSystemService(String)` para recuperar um `android.os.ProfilingManager`. (Herdado de Context)
ReceiverExported	Obsoleto. Sinalizador para `#registerReceiver`: o receptor pode receber transmissões de outros Aplicativos. (Herdado de Context)
ReceiverNotExported	Obsoleto. Sinalizador para `#registerReceiver`: o receptor não pode receber transmissões de outros Aplicativos. (Herdado de Context)
ReceiverVisibleToInstantApps	Obsoleto. Sinalizador para `#registerReceiver`: o receptor pode receber transmissões de Aplicativos Instantâneos. (Herdado de Context)
RestrictionsService	Use com `#getSystemService(String)` para recuperar uma `android.content.RestrictionsManager` para recuperar restrições de aplicativo e solicitar permissões para operações restritas. (Herdado de Context)
RoleService	Use com `#getSystemService(String)` para recuperar um `android.app.role.RoleManager` para gerenciar funções. (Herdado de Context)
SatelliteService	Use com `#getSystemService(String)` para recuperar um `android.telephony.satellite.SatelliteManager` para acessar a funcionalidade satélite. (Herdado de Context)
SearchService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.app.SearchManager` pesquisas. (Herdado de Context)
SecurityStateService	Use com `#getSystemService(String)` para recuperar um `android.os.SecurityStateManager` para acessar o serviço do gerenciador de estado de segurança. (Herdado de Context)
SensorService	Use com `#getSystemService(String)` para recuperar um `android.hardware.SensorManager` para acessar sensores. (Herdado de Context)
SerialService	Use com `#getSystemService(String)` para recuperar um `android.hardware.serial.SerialManager` acesso a portas seriais. (Herdado de Context)
ShortcutService	Use com `#getSystemService(String)` para recuperar um `android.content.pm.ShortcutManager` para acessar o serviço de atalho do inicializador. (Herdado de Context)
StatusBarService	Use com `#getSystemService(String)` para recuperar um `android.app.StatusBarManager` para interagir com a barra de status e configurações rápidas. (Herdado de Context)
StorageService	Use com `#getSystemService(String)` para recuperar um `android.os.storage.StorageManager` para acessar funções de armazenamento do sistema. (Herdado de Context)
StorageStatsService	Use com `#getSystemService(String)` para recuperar um `android.app.usage.StorageStatsManager` para acessar estatísticas de armazenamento do sistema. (Herdado de Context)
SystemHealthService	Use com `#getSystemService(String)` para recuperar uma `android.os.health.SystemHealthManager` para acessar as métricas de integridade do sistema (bateria, energia, memória etc.). (Herdado de Context)
TelecomService	Use com `#getSystemService(String)` para recuperar um `android.telecom.TelecomManager` para gerenciar recursos relacionados a telecomunicações do dispositivo. (Herdado de Context)
TelephonyImsService	Use com `#getSystemService(String)` para recuperar um `android.telephony.ims.ImsManager`. (Herdado de Context)
TelephonyPhoneNumberService	Use com `#getSystemService(String)` para recuperar um `android.telephony.PhoneNumberManager` para analisar números de telefone. (Herdado de Context)
TelephonyService	Use com `#getSystemService(String)` para recuperar um `android.telephony.TelephonyManager` para lidar com o gerenciamento dos recursos de telefonia do dispositivo. (Herdado de Context)
TelephonySubscriptionService	Use com `#getSystemService(String)` para recuperar um `android.telephony.SubscriptionManager` para lidar com o gerenciamento das assinaturas de telefonia do dispositivo. (Herdado de Context)
TetheringService	Use com `#getSystemService(String)` para recuperar um `android.net.TetheringManager` para gerenciar funções de amarração. (Herdado de Context)
TextClassificationService	Use com `#getSystemService(String)` para recuperar um `TextClassificationManager` para serviços de classificação de texto. (Herdado de Context)
TextServicesManagerService	Use com `#getSystemService(String)` para recuperar um `android.view.textservice.TextServicesManager` para acessar serviços de texto. (Herdado de Context)
TimeManagerService	Use com `#getSystemService(String)` para recuperar um `TimeManager`. (Herdado de Context)
TvAdService	Use com `#getSystemService(String)` para recuperar um `android.media.tv.ad.TvAdManager` para interagir com os serviços de anúncio do lado do cliente de TV no dispositivo. (Herdado de Context)
TvInputService	Use com `#getSystemService(String)` para recuperar um `android.media.tv.TvInputManager` para interagir com entradas de TV no dispositivo. (Herdado de Context)
TvInteractiveAppService	Use com `#getSystemService(String)` para recuperar um `android.media.tv.interactive.TvInteractiveAppManager` para interagir com aplicativos interativos de TV no dispositivo. (Herdado de Context)
UiModeService	Use com `#getSystemService(String)` para recuperar um `android.app.UiModeManager` para controlar os modos de interface do usuário. (Herdado de Context)
UsageStatsService	Use com `#getSystemService(String)` para recuperar um `android.app.usage.UsageStatsManager` para consultar estatísticas de uso do dispositivo. (Herdado de Context)
UsbService	Use com `#getSystemService(String)` para recuperar um `android.hardware.usb.UsbManager` acesso a dispositivos USB (como um host USB) e para controlar o comportamento desse dispositivo como um dispositivo USB. (Herdado de Context)
UserService	Use com `#getSystemService(String)` para recuperar um `android.os.UserManager` para gerenciar usuários em dispositivos que dão suporte a vários usuários. (Herdado de Context)
VibratorManagerService	Use com `#getSystemService(String)` para recuperar um `android.os.VibratorManager` para acessar os vibradores do dispositivo, interagir com os individuais e reproduzir efeitos sincronizados em vários vibradores. (Herdado de Context)
VibratorService	Use com `#getSystemService(String)` para recuperar um `android.os.Vibrator` para interagir com o hardware de vibração. (Herdado de Context)
VirtualDeviceService	Use com `#getSystemService(String)` para recuperar um `android.companion.virtual.VirtualDeviceManager` para gerenciar dispositivos virtuais. (Herdado de Context)
VpnManagementService	Use com `#getSystemService(String)` para recuperar um `android.net.VpnManager` para gerenciar perfis para a VPN interna da plataforma. (Herdado de Context)
WallpaperService	Use com `#getSystemService(String)` para recuperar um com. (Herdado de Context)
WebAppService	Use com `#getSystemService(String)` para recuperar um `android.content.pm.webapp.WebAppManager`. (Herdado de Context)
WifiAwareService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.net.wifi.aware.WifiAwareManager` o gerenciamento de Wi-Fi Aware. (Herdado de Context)
WifiP2pService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.net.wifi.p2p.WifiP2pManager` o gerenciamento de conexões ponto a ponto Wi-Fi. (Herdado de Context)
WifiRttRangingService	Use com `#getSystemService(String)` para recuperar um `android.net.wifi.rtt.WifiRttManager` dispositivo para dispositivos com wi-fi. (Herdado de Context)
WifiService	Use com para recuperar um `#getSystemService(String)` para lidar com `android.net.wifi.WifiManager` o gerenciamento de acesso Wi-Fi. (Herdado de Context)
WindowService	Use com `#getSystemService(String)` para recuperar um `android.view.WindowManager` para acessar o gerenciador de janelas do sistema. (Herdado de Context)

Propriedades

Nome	Description
ActionBar	Recupere uma referência ao ActionBar dessa atividade.
Application	Retorne o aplicativo que possui essa atividade.
ApplicationContext	Retorne o contexto do único objeto Application global do processo atual. (Herdado de ContextWrapper)
ApplicationInfo	Retorne as informações completas do aplicativo para o pacote deste contexto. (Herdado de ContextWrapper)
Assets	Retorne uma instância do AssetManager para o pacote do aplicativo. (Herdado de ContextWrapper)
AttributionSource	Obtém a fonte de atribuição associada a esse contexto. (Herdado de Context)
AttributionTag	A atribuição pode ser usada em aplicativos complexos para separar logicamente partes do aplicativo. (Herdado de Context)
BaseContext	(Herdado de ContextWrapper)
CacheDir	Retorna o caminho absoluto para o diretório de cache específico do aplicativo no sistema de arquivos. (Herdado de ContextWrapper)
Caller	Retorna a instância ComponentCaller do aplicativo que iniciou essa atividade.
CallingActivity	Retorne o nome da atividade que invocou essa atividade.
CallingPackage	Retorne o nome do pacote que invocou essa atividade.
ChangingConfigurations	Se essa atividade estiver sendo destruída porque não pode manipular um parâmetro de configuração que está sendo alterado (e, portanto, seu `#onConfigurationChanged(Configuration)` método não<> está <>sendo chamado), então você pode usar esse método para descobrir o conjunto de alterações que ocorreram durante o processo de destruição.
Class	Retorna a classe de runtime deste `Object`. (Herdado de Object)
ClassLoader	Retorne um carregador de classe que você pode usar para recuperar classes neste pacote. (Herdado de ContextWrapper)
CodeCacheDir	Retorna o caminho absoluto para o diretório de cache específico do aplicativo no sistema de arquivos projetado para armazenar código armazenado em cache. (Herdado de ContextWrapper)
ComponentName	Retorna o nome completo do componente dessa atividade.
ContentResolver	Retorne uma instância contentResolver para o pacote do aplicativo. (Herdado de ContextWrapper)
ContentScene	Recupere o `Scene` conteúdo atual da janela que representa essa janela.
ContentTransitionManager	Recupere o `TransitionManager` responsável pelas transições padrão nesta janela. -ou- Defina o `TransitionManager` uso para transições padrão nesta janela.
CurrentCaller	Retorna a instância ComponentCaller do aplicativo que reiniciou essa atividade com uma nova intenção por meio `#onNewIntent` ou `#onActivityResult`.
CurrentFocus	Chama `android.view.Window#getCurrentFocus` a janela desta atividade para retornar o modo de exibição focado no momento.
DataDir	Retorna o caminho absoluto para o diretório no sistema de arquivos em que todos os arquivos privados pertencentes a esse aplicativo são armazenados. Os aplicativos não devem usar esse caminho diretamente; em vez disso, eles devem usar getFilesDir() , getCacheDir() , getDir(String,int) ou outras APIs de armazenamento nessa classe. O caminho retornado poderá ser alterado ao longo do tempo se o aplicativo de chamada for movido para um dispositivo de armazenamento adotado, portanto, somente os caminhos relativos devem ser persistidos. Nenhuma permissão adicional é necessária para que o aplicativo de chamada leia ou escreva arquivos no caminho retornado. Retorna arquivo (Herdado de ContextWrapper)
DeviceId	Obtém a ID do dispositivo à qual esse contexto está associado. (Herdado de Context)
Display	Obtenha a exibição à qual esse contexto está associado. (Herdado de Context)
ExternalCacheDir	Retorna o caminho absoluto para o diretório no sistema de arquivos externo primário (que está em algum lugar em ExternalStorageDirectory que o aplicativo pode colocar arquivos de cache que possui. (Herdado de ContextWrapper)
FilesDir	Retorna o caminho absoluto para o diretório no sistema de arquivos com OpenFileOutput(String, FileCreationMode) o qual os arquivos criados são armazenados. (Herdado de ContextWrapper)
FocusedStateSet
FragmentManager	Retorne o FragmentManager para interagir com fragmentos associados a essa atividade.
Handle	O identificador para a instância subjacente do Android. (Herdado de Object)
HasWindowFocus	Retornará true se a janela em main<>/em< dessa atividade atualmente tiver o foco da >janela.
Immersive	Bit indicando que essa atividade é "imersiva" e não deve ser interrompida por notificações, se possível. -ou- Ajuste a configuração de modo imersivo atual.
InitialCaller	Retorna a instância ComponentCaller do aplicativo que inicialmente iniciou essa atividade.
InstanceCount
Intent	Retorna a intenção que iniciou essa atividade. -ou- Altera a intenção retornada por `#getIntent`.
IsActivityTransitionRunning	Retorna se há alguma transição de atividade atualmente em execução nesta atividade.
IsChangingConfigurations	Verifique se essa atividade está em processo de destruição para ser recriada com uma nova configuração.
IsChild	Se este é um filho `Activity` de um `ActivityGroup`.
IsDestroyed	Retornará true se a chamada final `#onDestroy()` tiver sido feita na Atividade, portanto, esta instância agora está morta.
IsDeviceProtectedStorage	Indica se as APIs de armazenamento desse Contexto são apoiadas pelo armazenamento protegido pelo dispositivo. (Herdado de ContextWrapper)
IsFinishing	Verifique se essa atividade está em processo de término, porque você a chamou `#finish` ou alguém solicitou que ela fosse concluída.
IsHandoffEnabled	Retorna se o Handoff tiver sido habilitado para essa Atividade.
IsInMultiWindowMode	Retornará true se a atividade estiver atualmente no modo de várias janelas.
IsInPictureInPictureMode	Retornará true se a atividade estiver atualmente no modo de imagem na imagem.
IsLaunchedFromBubble	Indica se essa atividade é iniciada de uma bolha.
IsLocalVoiceInteractionSupported	Consulta se o serviço de interação de voz atualmente habilitado dá suporte ao retorno de um interator de voz para uso pela atividade.
IsRestricted	Indica se esse contexto é restrito. (Herdado de Context)
IsTaskRoot	Retorne se essa atividade é a raiz de uma tarefa.
IsUiContext	Retorna `true` se o contexto for um contexto de interface do usuário que pode acessar componentes da interface do usuário, como `WindowManager`, `android.view.LayoutInflater LayoutInflater` ou `android.app.WallpaperManager WallpaperManager`. (Herdado de Context)
IsVoiceInteraction	Verifique se essa atividade está em execução como parte de uma interação de voz com o usuário.
IsVoiceInteractionRoot	Como `#isVoiceInteraction`, mas só retornará `true` se essa também for a raiz de uma interação de voz.
JniIdentityHashCode	Obtém o código de hash de identidade atribuído a esse par Java pelo runtime de interoperabilidade. (Herdado de Object)
JniManagedPeerState	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
JniPeerMembers	Fornece infraestrutura de associação JNI para Android.App.Activity.
LastNonConfigurationInstance	Recupere os dados da instância não configuração que foram retornados anteriormente por `#onRetainNonConfigurationInstance()`.
LaunchedFromPackage	Retorna o nome do pacote do aplicativo que inicialmente iniciou essa atividade.
LaunchedFromUid	Retorna a uid do aplicativo que inicialmente iniciou essa atividade.
LayoutInflater	Conveniência para chamar `android.view.Window#getLayoutInflater`.
LoaderManager	Retorne o LoaderManager para essa atividade, criando-o, se necessário.
LocalClassName	Retorna o nome da classe para essa atividade com o prefixo do pacote removido.
MainExecutor	Retornar um `Executor` que executará tarefas enfileiradas no thread principal associado a esse contexto. (Herdado de Context)
MainLooper	Retorne o Looper para o thread principal do processo atual. (Herdado de ContextWrapper)
MaxNumPictureInPictureActions	Retorne o número de ações que serão exibidas na interface do usuário de imagem na imagem quando o usuário interagir com a atividade atualmente no modo de imagem em imagem.
MaxNumPictureInPictureOverlayActions	Retorna o número máximo de ações de sobreposição que serão exibidas na janela imagem na imagem.
MediaController	Obtém o controlador que deve receber eventos de chave de mídia e volume enquanto essa atividade está em primeiro plano. -ou- Define um `MediaController` para o qual enviar chaves de mídia e alterações de volume.
MenuInflater	Retorna um `MenuInflater` com esse contexto.
NoBackupFilesDir	Retorna o caminho absoluto para o diretório no sistema de arquivos semelhante a FilesDir. (Herdado de ContextWrapper)
ObbDir	Retorne o diretório de armazenamento externo primário em que os arquivos OBB desse aplicativo (se houver algum) podem ser encontrados. (Herdado de ContextWrapper)
OnBackInvokedDispatcher	Retorna a `OnBackInvokedDispatcher` instância associada à janela à qual essa atividade está anexada.
OpPackageName	Retorne o nome do pacote que deve ser usado para `android.app.AppOpsManager` chamadas desse contexto, para que a verificação de uid do gerenciador de operações de aplicativo funcione com o nome. (Herdado de Context)
PackageCodePath	Retorne o caminho completo para o pacote principal do Android desse contexto. (Herdado de ContextWrapper)
PackageManager	Retornar a instância do PackageManager para encontrar informações de pacote global. (Herdado de ContextWrapper)
PackageName	Retorne o nome do pacote deste aplicativo. (Herdado de ContextWrapper)
PackageResourcePath	Retorne o caminho completo para o pacote principal do Android desse contexto. (Herdado de ContextWrapper)
Params	Retorne o conjunto de parâmetros com os quais esse Contexto foi criado, se ele foi criado por meio `#createContext(ContextParams)`de . (Herdado de Context)
Parent	Retorna o pai `Activity` se este for um filho `Activity` de um `ActivityGroup`.
ParentActivityIntent	Obtenha um `Intent` que iniciará uma atividade de destino explícita especificada pelo pai lógico dessa atividade.
PeerReference	Obtém a referência de objeto JNI para este par Java. (Herdado de Object)
Referrer	Retorne informações sobre quem iniciou essa atividade.
RequestedOrientation	Retorna a orientação solicitada atual da atividade, que é a orientação solicitada no manifesto do aplicativo ou a última orientação fornecida a `#setRequestedOrientation(int)`. -ou- Alterar a orientação desejada dessa atividade.
Resources	Retornar uma instância de Recursos para o pacote do aplicativo. (Herdado de ContextWrapper)
SearchEvent	Durante os retornos de chamada onSearchRequested(), essa função retornará o `SearchEvent` que disparou o retorno de chamada, se existir.
SplashScreen	Obtenha a interface que a atividade usa para falar com a tela inicial.
TaskId	Retorne o identificador da tarefa em que esta atividade está.
Theme	Retorne o objeto Theme associado a este Contexto. (Herdado de ContextWrapper)
ThresholdClass	Fornece infraestrutura de associação JNI para Android.App.Activity.
ThresholdType	Fornece infraestrutura de associação JNI para Android.App.Activity.
Title
TitleColor	Obsoleto. Altere a cor do título associado a essa atividade.
TitleFormatted	Altere o título associado a essa atividade.
UpdateableFlags	Obtém a lista de sinalizadores de associação que podem ser atualizados (ou seja, adicionados ou removidos) para uma conexão existente. (Herdado de Context)
VoiceInteractor	Recupere o ativo `VoiceInteractor` pelo qual o usuário está passando para interagir com essa atividade.
VolumeControlStream	Obtém o fluxo de áudio sugerido cujo volume deve ser alterado pelos controles de volume de hardware. -ou- Sugere um fluxo de áudio cujo volume deve ser alterado pelos controles de volume de hardware.
Wallpaper	Obsoleto. (Herdado de ContextWrapper)
WallpaperDesiredMinimumHeight	Obsoleto. (Herdado de ContextWrapper)
WallpaperDesiredMinimumWidth	Obsoleto. (Herdado de ContextWrapper)
Window	Recupere a corrente `android.view.Window` para a atividade.
WindowManager	Recupere o gerenciador de janelas para mostrar janelas personalizadas.

Métodos

Nome	Description
AddContentView(View, ViewGroup+LayoutParams)	Adicione uma exibição de conteúdo adicional à atividade.
ApplyOverrideConfiguration(Configuration)	Chame para definir uma "configuração de substituição" nesse contexto. Essa é uma configuração que responde a um ou mais valores da configuração padrão que é aplicada ao contexto. (Herdado de ContextThemeWrapper)
AttachBaseContext(Context)	Defina o contexto base para este ContextWrapper. (Herdado de ContextWrapper)
BindIsolatedService(Intent, Context+BindServiceFlags, String, IExecutor, IServiceConnection)	Consulte bindIsolatedService(Intent,int,String,Executor,ServiceConnection) Call BindServiceFlags.of(long) para obter um objeto BindServiceFlags. (Herdado de Context)
BindIsolatedService(Intent, Int32, String, IExecutor, IServiceConnection)	A variação disso `#bindService` , no caso específico de serviços isolados, permite que o chamador gere várias instâncias de um serviço de uma única declaração de componente. (Herdado de Context)
BindService(Intent, Bind, IExecutor, IServiceConnection)	`#bindService(Intent, ServiceConnection, int) bindService(Intent, ServiceConnection, int)` Igual ao executor para controlar os retornos de chamada do ServiceConnection. (Herdado de Context)
BindService(Intent, Context+BindServiceFlags, IExecutor, IServiceConnection)	Consulte bindService(Intent,int,Executor,ServiceConnection) Call BindServiceFlags.of(long) to obtain a BindServiceFlags object. (Herdado de Context)
BindService(Intent, IServiceConnection, Bind)	Conecte-se a um serviço de aplicativo, criando-o, se necessário. (Herdado de ContextWrapper)
BindService(Intent, IServiceConnection, Context+BindServiceFlags)	Consulte bindService(Intent,ServiceConnection,int) Call BindServiceFlags.of(long) to obtain a BindServiceFlags object. (Herdado de Context)
BindServiceAsUser(Intent, IServiceConnection, Context+BindServiceFlags, UserHandle)	Consulte bindServiceAsUser(Intent,ServiceConnection,int,UserHandle) Call BindServiceFlags.of(long) to obtain a BindServiceFlags object. (Herdado de Context)
BindServiceAsUser(Intent, IServiceConnection, Int32, UserHandle)	Associa a um serviço da `user` mesma maneira `#bindService`que . (Herdado de Context)
CheckCallingOrSelfPermission(String)	Determine se o processo de chamada de um IPC ou você recebeu uma permissão específica. (Herdado de ContextWrapper)
CheckCallingOrSelfUriPermission(Uri, ActivityFlags)	Determine se o processo de chamada de um IPC ou você recebeu permissão para acessar um URI específico. (Herdado de ContextWrapper)
CheckCallingOrSelfUriPermissions(IList<Uri>, Int32)	Determine se o processo de chamada de um IPC <em>ou você</em> recebeu permissão para acessar uma lista de URIs. (Herdado de Context)
CheckCallingPermission(String)	Determine se o processo de chamada de um IPC que você está tratando recebeu uma permissão específica. (Herdado de ContextWrapper)
CheckCallingUriPermission(Uri, ActivityFlags)	Determine se o processo de chamada e a ID do usuário receberam permissão para acessar um URI específico. (Herdado de ContextWrapper)
CheckCallingUriPermissions(IList<Uri>, Int32)	Determine se o processo de chamada e o uid receberam permissão para acessar uma lista de URIs. (Herdado de Context)
CheckContentUriPermissionFull(Uri, Int32, Int32, ActivityFlags)	Determine se um processo específico e uid receberam permissão para acessar um URI de conteúdo específico. (Herdado de Context)
CheckPermission(String, Int32, Int32)	Determine se a permissão fornecida é permitida para um processo específico e ID de usuário em execução no sistema. (Herdado de ContextWrapper)
CheckSelfPermission(String)	Determine se você recebeu uma permissão específica. (Herdado de ContextWrapper)
CheckUriPermission(Uri, Int32, Int32, ActivityFlags)	Determine se um processo específico e uma ID de usuário receberam permissão para acessar um URI específico. (Herdado de ContextWrapper)
CheckUriPermission(Uri, String, String, Int32, Int32, ActivityFlags)	Verifique um Uri e uma permissão normal. (Herdado de ContextWrapper)
CheckUriPermissions(IList<Uri>, Int32, Int32, Int32)	Determine se um processo específico e uid receberam permissão para acessar uma lista de URIs. (Herdado de Context)
ClearOverrideActivityTransition(OverrideTransition)	Limpa as animações que são definidas de `#overrideActivityTransition`.
ClearWallpaper()	Obsoleto. (Herdado de ContextWrapper)
Clone()	Cria e retorna uma cópia desse objeto. (Herdado de Object)
CloseContextMenu()	Fecha programaticamente o menu de contexto aberto mais recentemente, se exibido.
CloseOptionsMenu()	Fecha progamticamente o menu de opções.
Construct(JniObjectReference, JniObjectReferenceOptions)	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
CreateAttributionContext(String)	Retornar um novo objeto Context para o Contexto atual, mas atributo a uma marca diferente. (Herdado de Context)
CreateConfigurationContext(Configuration)	Retornar um novo objeto Context para o Contexto atual, mas cujos recursos são ajustados para corresponder à configuração fornecida. (Herdado de ContextWrapper)
CreateContext(ContextParams)	Cria um contexto com propriedades e comportamentos específicos. (Herdado de Context)
CreateContextForSplit(String)	Retornar um novo objeto Context para o nome de divisão fornecido. O novo contexto tem um objeto ClassLoader e Resources que pode acessar o código/recursos da divisão e todas as dependências. Cada chamada a esse método retorna uma nova instância de um objeto Context; Objetos de contexto não são compartilhados, porém o estado comum (ClassLoader, outros recursos para a mesma divisão) pode ser para que o contexto em si possa ser bastante leve. (Herdado de ContextWrapper)
CreateDeviceContext(Int32)	Retorna um novo `Context` objeto do contexto atual, mas com a associação de dispositivo fornecida pelo `deviceId`. (Herdado de Context)
CreateDeviceProtectedStorageContext()	Retornar um novo objeto Context para o Contexto atual, mas cujas APIs de armazenamento são apoiadas pelo armazenamento protegido pelo dispositivo. Em dispositivos com inicialização direta, os dados armazenados nesse local são criptografados com uma chave vinculada ao dispositivo físico e podem ser acessados imediatamente após o dispositivo ter sido inicializado com êxito, antes e depois que o usuário tiver autenticado com suas credenciais (como um padrão de bloqueio ou PIN). Como os dados protegidos pelo dispositivo estão disponíveis sem autenticação do usuário, você deve limitar cuidadosamente os dados armazenados usando este Contexto. Por exemplo, o armazenamento de tokens de autenticação confidenciais ou senhas na área protegida pelo dispositivo é altamente desencorajado. Se o dispositivo subjacente não tiver a capacidade de armazenar dados protegidos por dispositivo e protegidos por credenciais usando chaves diferentes, ambas as áreas de armazenamento ficarão disponíveis ao mesmo tempo. Eles permanecem como dois locais de armazenamento distintos no disco e apenas a janela de disponibilidade muda. Cada chamada a esse método retorna uma nova instância de um objeto Context; Objetos de contexto não são compartilhados, porém o estado comum (ClassLoader, outros recursos para a mesma configuração) pode ser para que o contexto em si possa ser bastante leve. Retorna Contexto (Herdado de ContextWrapper)
CreateDisplayContext(Display)	Retornar um novo objeto Context para o Contexto atual, mas cujos recursos são ajustados para corresponder às métricas da exibição fornecida. (Herdado de ContextWrapper)
CreatePackageContext(String, PackageContextFlags)	Retornar um novo objeto Context para o nome do aplicativo fornecido. (Herdado de ContextWrapper)
CreatePendingResult(Int32, Intent, PendingIntentFlags)	Crie um novo objeto PendingIntent que você pode entregar a outras pessoas para que elas usem para enviar dados de resultado de volta para o retorno `#onActivityResult` de chamada.
CreateWindowContext(Display, Int32, Bundle)	Cria um `Context` para uma janela que não seja`android.app.Activity activity` no determinado `Display`. (Herdado de Context)
CreateWindowContext(Int32, Bundle)	Cria um contexto para uma janela que não seja de atividade. (Herdado de Context)
DatabaseList()	Retorna uma matriz de cadeias de caracteres nomeando os bancos de dados privados associados ao pacote de aplicativos deste Contexto. (Herdado de ContextWrapper)
DeleteDatabase(String)	Exclua um SQLiteDatabase privado existente associado ao pacote de aplicativos deste Contexto. (Herdado de ContextWrapper)
DeleteFile(String)	Exclua o arquivo privado especificado associado ao pacote de aplicativos deste Contexto. (Herdado de ContextWrapper)
DeleteSharedPreferences(String)	Exclua um arquivo de preferências compartilhadas existente. (Herdado de ContextWrapper)
DismissDialog(Int32)	Obsoleto. Ignorar uma caixa de diálogo que foi mostrada anteriormente por meio de `#showDialog(int)`.
DismissKeyboardShortcutsHelper()	Ignore a tela Atalhos de Teclado.
DispatchGenericMotionEvent(MotionEvent)	Chamado para processar eventos de movimento genéricos.
DispatchKeyEvent(KeyEvent)	Chamado para processar eventos principais.
DispatchKeyShortcutEvent(KeyEvent)	Chamado para processar um evento de atalho de chave.
DispatchPopulateAccessibilityEvent(AccessibilityEvent)	Chamado para processar a população de AccessibilityEvents.
DispatchTouchEvent(MotionEvent)	Chamado para processar eventos de tela sensível ao toque.
DispatchTrackballEvent(MotionEvent)	Chamado para processar eventos de trackball.
Dispose()	Libera os recursos mantidos por esse par Java. (Herdado de Object)
Dispose(Boolean)	Libera os recursos mantidos por esse par Java. (Herdado de Object)
DisposeUnlessReferenced()	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
Dump(String, FileDescriptor, PrintWriter, String[])	Imprima o estado da Atividade no fluxo fornecido.
EnforceCallingOrSelfPermission(String, String)	Se nem você nem o processo de chamada de um IPC que você está tratando receberem uma permissão específica, gere um SecurityException. (Herdado de ContextWrapper)
EnforceCallingOrSelfUriPermission(Uri, ActivityFlags, String)	Se o processo de chamada de um IPC ou você não tiver recebido permissão para acessar um URI específico, gere SecurityException. (Herdado de ContextWrapper)
EnforceCallingPermission(String, String)	Se o processo de chamada de um IPC que você está tratando não tiver recebido uma permissão específica, gere uma SecurityException. (Herdado de ContextWrapper)
EnforceCallingUriPermission(Uri, ActivityFlags, String)	Se o processo de chamada e a ID do usuário não tiverem recebido permissão para acessar um URI específico, jogue SecurityException. (Herdado de ContextWrapper)
EnforcePermission(String, Int32, Int32, String)	Se a permissão fornecida não for permitida para um processo específico e a ID do usuário em execução no sistema, gere um SecurityException. (Herdado de ContextWrapper)
EnforceUriPermission(Uri, Int32, Int32, ActivityFlags, String)	Se um processo específico e uma ID de usuário não tiverem recebido permissão para acessar um URI específico, gere SecurityException. (Herdado de ContextWrapper)
EnforceUriPermission(Uri, String, String, Int32, Int32, ActivityFlags, String)	Imponha um Uri e uma permissão normal. (Herdado de ContextWrapper)
EnterPictureInPictureMode()	Coloca a atividade no modo de imagem em imagem, se possível, no estado atual do sistema.
EnterPictureInPictureMode(PictureInPictureParams)	Coloca a atividade no modo de imagem em imagem, se possível, no estado atual do sistema.
Equals(Object)	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
Equals(Object)	Indica se algum outro objeto é "igual a" este. (Herdado de Object)
FileList()	Retorna uma matriz de cadeias de caracteres nomeando os arquivos privados associados ao pacote de aplicativos deste Contexto. (Herdado de ContextWrapper)
FindViewById(Int32)	Localiza uma exibição que foi identificada pelo `android:id` atributo XML que foi processado em `#onCreate`.
FindViewById<T>(Int32)	Localiza uma exibição que foi identificada pelo atributo ID do recurso de layout XML.
Finish()	Chame isso quando sua atividade for concluída e deverá ser fechada.
FinishActivity(Int32)	Forçar o término de outra atividade com `#startActivityForResult`a qual você havia começado anteriormente.
FinishActivityFromChild(Activity, Int32)	Isso é chamado quando uma atividade filho deste chama sua finishActivity().
FinishAffinity()	Conclua essa atividade, bem como todas as atividades imediatamente abaixo dela na tarefa atual que têm a mesma afinidade.
FinishAfterTransition()	Inverte a Transição de Entrada da Cena de Atividade e dispara a atividade de chamada para reverter sua transição de saída.
FinishAndRemoveTask()	Chame isso quando sua atividade for concluída e deve ser fechada e a tarefa deve ser completamente removida como parte do término da atividade raiz da tarefa.
FinishFromChild(Activity)	Isso é chamado quando uma atividade filho deste chama seu `#finish` método.
GetColor(Int32)	Retorna uma cor associada a uma ID de recurso específica e estilizada para o tema atual. (Herdado de Context)
GetColorStateList(Int32)	Retorna uma lista de estado de cor associada a uma ID de recurso específica e estilizada para o tema atual. (Herdado de Context)
GetDatabasePath(String)	Retorna o caminho absoluto no sistema de arquivos em que um banco de dados criado com openOrCreateDatabase(String, int, CursorFactory) é armazenado. O caminho retornado poderá ser alterado ao longo do tempo se o aplicativo de chamada for movido para um dispositivo de armazenamento adotado, portanto, somente os caminhos relativos devem ser persistidos. (Herdado de ContextWrapper)
GetDir(String, FileCreationMode)	Recupere, criando, se necessário, um novo diretório no qual o aplicativo pode colocar seus próprios arquivos de dados personalizados. (Herdado de ContextWrapper)
GetDrawable(Int32)	Retorna um objeto desenhável associado a uma ID de recurso específica e estilizado para o tema atual. (Herdado de Context)
GetExternalCacheDirs()	Retorna caminhos absolutos para diretórios específicos do aplicativo em todos os dispositivos de armazenamento externos em que o aplicativo pode colocar arquivos de cache que possui. (Herdado de ContextWrapper)
GetExternalFilesDir(String)	Retorna o caminho absoluto para o diretório no sistema de arquivos externo primário (que está em algum lugar) ExternalStorageDirectoryem que o aplicativo pode colocar arquivos persistentes que possui. (Herdado de ContextWrapper)
GetExternalFilesDirs(String)	Retorna caminhos absolutos para diretórios específicos do aplicativo em todos os dispositivos de armazenamento externos em que o aplicativo pode colocar arquivos persistentes que possui. (Herdado de ContextWrapper)
GetExternalMediaDirs()	Obsoleto. Retorna caminhos absolutos para diretórios específicos do aplicativo em todos os dispositivos de armazenamento externos em que o aplicativo pode colocar arquivos de mídia. (Herdado de ContextWrapper)
GetFileStreamPath(String)	Retorna o caminho absoluto no sistema de arquivos em que um arquivo criado com OpenFileOutput(String, FileCreationMode) é armazenado. (Herdado de ContextWrapper)
GetHashCode()	Retorna um valor de código hash para o objeto. (Herdado de Object)
GetObbDirs()	Retorna caminhos absolutos para diretórios específicos do aplicativo em todos os dispositivos de armazenamento externos em que os arquivos OBB do aplicativo (se houver algum) podem ser encontrados. (Herdado de ContextWrapper)
GetPreferences(FileCreationMode)	Recupere um `SharedPreferences` objeto para acessar preferências privadas para essa atividade.
GetSharedPreferences(String, FileCreationMode)	Recupere e mantenha o conteúdo do arquivo de preferências 'name', retornando um SharedPreferences por meio do qual você pode recuperar e modificar seus valores. (Herdado de ContextWrapper)
GetString(Int32, Object[])	Retorna uma cadeia de caracteres localizada da tabela de cadeia de caracteres padrão do pacote do aplicativo. (Herdado de Context)
GetString(Int32)	Retorna uma cadeia de caracteres localizada da tabela de cadeia de caracteres padrão do pacote do aplicativo. (Herdado de Context)
GetSystemService(Class)	Retorne o identificador para um serviço no nível do sistema por classe. (Herdado de Context)
GetSystemService(String)	Retorne o identificador para um serviço no nível do sistema pelo nome. (Herdado de ContextWrapper)
GetSystemServiceName(Class)	Obtém o nome do serviço no nível do sistema que é representado pela classe especificada. (Herdado de ContextWrapper)
GetText(Int32)	Retorne um CharSequence localizado e com estilo da tabela de cadeia de caracteres padrão do pacote do aplicativo. (Herdado de Context)
GetTextFormatted(Int32)	Retorne um CharSequence localizado e com estilo da tabela de cadeia de caracteres padrão do pacote do aplicativo. (Herdado de Context)
GrantUriPermission(String, Uri, ActivityFlags)	Conceda permissão para acessar um Uri específico a outro pacote, independentemente de esse pacote ter permissão geral para acessar o provedor de conteúdo do Uri. (Herdado de ContextWrapper)
InvalidateOptionsMenu()	Declare que o menu de opções foi alterado, portanto, deve ser recriado.
JavaFinalize()	Obsoleto. Chamado pelo coletor de lixo em um objeto quando a coleta de lixo determina que não há mais referências ao objeto. (Herdado de Object)
ManagedQuery(Uri, String[], String, String[], String)	Obsoleto. Wrapper ao redor `ContentResolver#query(android.net.Uri , String[], String, String[], String)`que fornece a chamada `Cursor` resultante `#startManagingCursor` para que a atividade gerencie seu ciclo de vida para você.
MoveDatabaseFrom(Context, String)	Mova um arquivo de banco de dados existente do contexto de armazenamento de origem fornecido para esse contexto. Normalmente, isso é usado para migrar dados entre locais de armazenamento após uma atualização, como migrar para o armazenamento protegido pelo dispositivo. O banco de dados deve ser fechado antes de ser movido. (Herdado de ContextWrapper)
MoveSharedPreferencesFrom(Context, String)	Mova um arquivo de preferências compartilhadas existente do contexto de armazenamento de origem fornecido para esse contexto. Normalmente, isso é usado para migrar dados entre locais de armazenamento após uma atualização, como mover para o armazenamento protegido pelo dispositivo. (Herdado de ContextWrapper)
MoveTaskToBack(Boolean)	Mova a tarefa que contém essa atividade para a parte de trás da pilha de atividades.
NavigateUpTo(Intent)	Navegue dessa atividade até a atividade especificada por upIntent, terminando essa atividade no processo.
NavigateUpToFromChild(Activity, Intent)	Isso é chamado quando uma atividade filho deste chama seu `#navigateUpTo` método.
Notify()	Ativa um único thread que está aguardando no monitor deste objeto. (Herdado de Object)
NotifyAll()	Ativa todos os threads que estão aguardando no monitor deste objeto. (Herdado de Object)
ObtainStyledAttributes(IAttributeSet, Int32[], Int32, Int32)	Recupere informações de atributo com estilo no tema deste Contexto. (Herdado de Context)
ObtainStyledAttributes(IAttributeSet, Int32[])	Recupere informações de atributo com estilo no tema deste Contexto. (Herdado de Context)
ObtainStyledAttributes(Int32, Int32[])	Recupere informações de atributo com estilo no tema deste Contexto. (Herdado de Context)
ObtainStyledAttributes(Int32[])	Recupere informações de atributo com estilo no tema deste Contexto. (Herdado de Context)
OnActionModeFinished(ActionMode)	Notifica a atividade que um modo de ação terminou.
OnActionModeStarted(ActionMode)	Notifica a Atividade de que um modo de ação foi iniciado.
OnActivityReenter(Int32, Intent)	Chamado quando uma atividade que você iniciou com uma transição de atividade expõe essa Atividade por meio de uma transição de atividade retornada, dando a você o resultCode e quaisquer dados adicionais dela.
OnActivityResult(Int32, Result, Intent, ComponentCaller)	O mesmo que `#onActivityResult(int, int, Intent)`, mas com um parâmetro extra para a instância ComponentCaller associada ao aplicativo que enviou o resultado.
OnActivityResult(Int32, Result, Intent)	Chamado quando uma atividade que você iniciou sai, dando-lhe o requestCode com o qual você iniciou, o resultCode retornado e quaisquer dados adicionais dele.
OnApplyThemeResource(Resources+Theme, Int32, Boolean)	Chamado e `#setTheme#getTheme` para aplicar um recurso de tema ao objeto Theme atual. (Herdado de ContextThemeWrapper)
OnAttachedToWindow()	Chamado quando a janela principal associada à atividade foi anexada ao gerenciador de janelas.
OnAttachFragment(Fragment)	Chamado quando um fragmento está sendo anexado a essa atividade, imediatamente após a chamada para seu `Fragment#onAttach Fragment.onAttach()` método e antes `Fragment#onCreate Fragment.onCreate()`.
OnBackPressed()	Chamado quando a atividade detectou a pressão do usuário da tecla de fundo.
OnChildTitleChanged(Activity, ICharSequence)
OnChildTitleChanged(Activity, String)
OnConfigurationChanged(Configuration)	Chamado pelo sistema quando a configuração do dispositivo é alterada enquanto sua atividade está em execução.
OnContentChanged()	Esse gancho é chamado sempre que a exibição de conteúdo da tela é alterada (devido a uma chamada para Window.setContentView ou Window.addContentView).
OnContextItemSelected(IMenuItem)	Esse gancho é chamado sempre que um item em um menu de contexto é selecionado.
OnContextMenuClosed(IMenu)	Esse gancho é chamado sempre que o menu de contexto está sendo fechado (seja pelo usuário cancelando o menu com o botão voltar/menu ou quando um item é selecionado).
OnCreate(Bundle, PersistableBundle)	O mesmo, `#onCreate(android.os.Bundle)` mas chamado para essas atividades criadas com o atributo `android.R.attr#persistableMode` definido como `persistAcrossReboots`.
OnCreate(Bundle)	Chamado quando a atividade está sendo iniciada.
OnCreateContextMenu(IContextMenu, View, IContextMenuContextMenuInfo)	Chamado quando um menu de contexto para a exibição está prestes a ser mostrado.
OnCreateDescription()	Gere uma nova descrição para essa atividade.
OnCreateDescriptionFormatted()	Gere uma nova descrição para essa atividade.
OnCreateDialog(Int32, Bundle)	Obsoleto. Retorno de chamada para criar caixas de diálogo gerenciadas (salvas e restauradas) para você pela atividade.
OnCreateDialog(Int32)	Obsoleto. Esse método foi preterido no nível 15 da API.
OnCreateNavigateUpTaskStack(TaskStackBuilder)	Defina a pilha de tarefas sintéticas que será gerada durante a navegação up de uma tarefa diferente.
OnCreateOptionsMenu(IMenu)	Inicialize o conteúdo do menu de opções padrão da Atividade.
OnCreatePanelMenu(Int32, IMenu)	Implementação padrão de `android.view.Window.Callback#onCreatePanelMenu` para atividades.
OnCreatePanelView(Int32)	Implementação padrão de `android.view.Window.Callback#onCreatePanelView` para atividades.
OnCreateThumbnail(Bitmap, Canvas)	Esse método foi preterido no nível 28 da API.
OnCreateView(String, Context, IAttributeSet)	Implementação padrão de `android.view.LayoutInflater.Factory#onCreateView` usado ao inflar com o LayoutInflater retornado por `#getSystemService`.
OnCreateView(View, String, Context, IAttributeSet)	Implementação padrão de `android.view.LayoutInflater.Factory2#onCreateView(View, String, Context, AttributeSet)` usado ao inflar com o LayoutInflater retornado por `#getSystemService`.
OnDestroy()	Execute qualquer limpeza final antes que uma atividade seja destruída.
OnDetachedFromWindow()	Chamado quando a janela principal associada à atividade foi desanexada do gerenciador de janelas.
OnEnterAnimationComplete()	As atividades não podem ser desenhadas durante o período em que suas janelas estão se animando.
OnGenericMotionEvent(MotionEvent)	Chamado quando um evento de movimento genérico não foi tratado por nenhuma das exibições dentro da atividade.
OnGetDirectActions(CancellationSignal, IConsumer)	Retorna a lista de ações diretas compatíveis com o aplicativo.
OnHandoffActivityDataRequested(HandoffActivityDataRequestInfo)	Recupera a `HandoffActivityData` representação dessa atividade, permitindo que ela seja recriada em outro dispositivo de propriedade do usuário.
OnKeyDown(Keycode, KeyEvent)	Chamado quando uma tecla foi pressionada para baixo e não tratada por nenhuma das exibições dentro da atividade.
OnKeyLongPress(Keycode, KeyEvent)	A implementação padrão de `KeyEvent.Callback#onKeyLongPress(int, KeyEvent) KeyEvent.Callback.onKeyLongPress()`: sempre retorna false (não manipula o evento).
OnKeyMultiple(Keycode, Int32, KeyEvent)	A implementação padrão de `KeyEvent.Callback#onKeyMultiple(int, int, KeyEvent) KeyEvent.Callback.onKeyMultiple()`: sempre retorna false (não manipula o evento).
OnKeyShortcut(Keycode, KeyEvent)	Chamado quando um evento de atalho de chave não é tratado por nenhuma das exibições na Atividade.
OnKeyUp(Keycode, KeyEvent)	Chamado quando uma chave foi liberada e não tratada por nenhuma das exibições dentro da atividade.
OnLocalVoiceInteractionStarted()	Retorno de chamada para indicar que `#startLocalVoiceInteraction(Bundle)` resultou no início de uma sessão de interação de voz.
OnLocalVoiceInteractionStopped()	Retorno de chamada para indicar que a interação de voz local parou porque foi solicitada por meio de uma chamada para `#stopLocalVoiceInteraction()` ou porque foi cancelada pelo usuário.
OnLowMemory()	Isso é chamado quando o sistema geral está com pouca memória e os processos em execução ativamente devem cortar o uso da memória.
OnMenuItemSelected(Int32, IMenuItem)	Implementação padrão de `android.view.Window.Callback#onMenuItemSelected` para atividades.
OnMenuOpened(Int32, IMenu)	Chamado quando o menu de um painel é aberto pelo usuário.
OnMultiWindowModeChanged(Boolean, Configuration)	Chamado pelo sistema quando a atividade muda do modo de tela inteira para o modo de várias janelas e visa-versa.
OnMultiWindowModeChanged(Boolean)	Chamado pelo sistema quando a atividade muda do modo de tela inteira para o modo de várias janelas e visa-versa.
OnNavigateUp()	Esse método é chamado sempre que o usuário opta por navegar até dentro da hierarquia de atividades do aplicativo na barra de ações.
OnNavigateUpFromChild(Activity)	Isso é chamado quando uma atividade filho deste tenta navegar para cima.
OnNewIntent(Intent, ComponentCaller)	O mesmo que `#onNewIntent(Intent)`, mas com um parâmetro extra para a instância ComponentCaller associada ao aplicativo que enviou a intenção.
OnNewIntent(Intent)	Isso é chamado para atividades que definem launchMode como "singleTop" em seu pacote ou se um cliente usou o `Intent#FLAG_ACTIVITY_SINGLE_TOP` sinalizador ao chamar `#startActivity`.
OnOptionsItemSelected(IMenuItem)	Esse gancho é chamado sempre que um item no menu de opções é selecionado.
OnOptionsMenuClosed(IMenu)	Esse gancho é chamado sempre que o menu de opções está sendo fechado (seja pelo usuário cancelando o menu com o botão voltar/menu ou quando um item é selecionado).
OnPanelClosed(Int32, IMenu)	Implementação padrão de `android.view.Window.Callback#onPanelClosed(int, Menu)` atividades.
OnPause()	Chamado como parte do ciclo de vida da atividade quando o usuário não interage mais ativamente com a atividade, mas ainda está visível na tela.
OnPerformDirectAction(String, Bundle, CancellationSignal, IConsumer)	Isso é chamado para executar uma ação definida anteriormente pelo aplicativo.
OnPictureInPictureModeChanged(Boolean, Configuration)	Chamado pelo sistema quando a atividade muda de e para o modo de imagem na imagem.
OnPictureInPictureModeChanged(Boolean)	Chamado pelo sistema quando a atividade muda de e para o modo de imagem na imagem.
OnPictureInPictureRequested()	Esse método é chamado pelo sistema em vários casos em que a imagem no modo de imagem deve ser inserida se houver suporte.
OnPictureInPictureUiStateChanged(PictureInPictureUiState)	Chamado pelo sistema quando a atividade está no PiP e tem alterações de estado.
OnPostCreate(Bundle, PersistableBundle)	Isso é o mesmo que `#onPostCreate(Bundle)` , mas é chamado para atividades criadas com o atributo `android.R.attr#persistableMode` definido como `persistAcrossReboots`.
OnPostCreate(Bundle)	Chamado quando a inicialização da atividade for concluída (depois `#onStart` e `#onRestoreInstanceState` ter sido chamada).
OnPostResume()	Chamado quando o currículo da atividade é concluído (depois `#onResume` de ter sido chamado).
OnPrepareDialog(Int32, Dialog, Bundle)	Obsoleto. Oferece uma oportunidade de preparar uma caixa de diálogo gerenciada antes de ser mostrada.
OnPrepareDialog(Int32, Dialog)	Obsoleto. Esse método foi preterido no nível 15 da API.
OnPrepareNavigateUpTaskStack(TaskStackBuilder)	Prepare a pilha de tarefas sintéticas que será gerada durante a navegação up de uma tarefa diferente.
OnPrepareOptionsMenu(IMenu)	Prepare o menu de opções padrão da Tela a ser exibido.
OnPreparePanel(Int32, View, IMenu)	Implementação padrão de `android.view.Window.Callback#onPreparePanel` para atividades.
OnProvideAssistContent(AssistContent)	Isso é chamado quando o usuário está solicitando uma assistência para fornecer referências ao conteúdo relacionado à atividade atual.
OnProvideAssistData(Bundle)	Isso é chamado quando o usuário está solicitando uma assistência para criar uma Intenção completa `Intent#ACTION_ASSIST` com todo o contexto do aplicativo atual.
OnProvideKeyboardShortcuts(IList<KeyboardShortcutGroup>, IMenu, Int32)	Chamado quando atalhos de teclado são solicitados para a janela atual.
OnProvideReferrer()	Substitua para gerar o referenciador desejado para o conteúdo mostrado atualmente pelo aplicativo.
OnRequestPermissionsResult(Int32, String[], Permission[], Int32)	Retorno de chamada para o resultado da solicitação de permissões.
OnRequestPermissionsResult(Int32, String[], Permission[])	Retorno de chamada para o resultado da solicitação de permissões.
OnRestart()	Chamado depois de `#onStop` quando a atividade atual está sendo exibida novamente para o usuário (o usuário navegou de volta para ela).
OnRestoreInstanceState(Bundle, PersistableBundle)	Isso é o mesmo que `#onRestoreInstanceState(Bundle)` , mas é chamado para atividades criadas com o atributo `android.R.attr#persistableMode` definido como `persistAcrossReboots`.
OnRestoreInstanceState(Bundle)	Esse método é chamado após `#onStart` quando a atividade está sendo inicializada novamente de um estado salvo anteriormente, dado aqui em <var>savedInstanceState</var>.
OnResume()	Chamado depois `#onRestoreInstanceState`, `#onRestart`ou `#onPause`.
OnRetainNonConfigurationInstance()	Chamado pelo sistema, como parte da destruição de uma atividade devido a uma alteração de configuração, quando se sabe que uma nova instância será criada imediatamente para a nova configuração.
OnSaveInstanceState(Bundle, PersistableBundle)	Isso é o mesmo que `#onSaveInstanceState` , mas é chamado para atividades criadas com o atributo `android.R.attr#persistableMode` definido como `persistAcrossReboots`.
OnSaveInstanceState(Bundle)	Chamado para recuperar o estado por instância de uma atividade antes de ser morto para que o estado possa ser restaurado ou `#onCreate#onRestoreInstanceState` (o `Bundle` povoado por esse método será passado para ambos).
OnSearchRequested()	Chamado quando o usuário sinaliza o desejo de iniciar uma pesquisa.
OnSearchRequested(SearchEvent)	Esse gancho é chamado quando o usuário sinaliza o desejo de iniciar uma pesquisa.
OnStart()	Chamado após `#onCreate` — ou depois quando `#onRestart` a atividade foi interrompida, mas agora está sendo exibida novamente para o usuário.
OnStateNotSaved()	Chamado quando um `#onResume` está chegando, antes de outros retornos de chamada pré-retomar, como `#onNewIntent` e `#onActivityResult`.
OnStop()	Chamado quando você não está mais visível para o usuário.
OnTitleChanged(ICharSequence, Color)
OnTitleChanged(String, Color)
OnTopResumedActivityChanged(Boolean)	Chamado quando a atividade obtém ou perde a posição mais alta retomada no sistema.
OnTouchEvent(MotionEvent)	Chamado quando um evento de tela sensível ao toque não foi tratado por nenhuma das exibições dentro da atividade.
OnTrackballEvent(MotionEvent)	Chamado quando o trackball foi movido e não tratado por nenhuma das exibições dentro da atividade.
OnTrimMemory(TrimMemory)	Chamado quando o sistema operacional determinou que é um bom momento para um processo cortar a memória desnecessária de seu processo.
OnUserInteraction()	Chamado sempre que um evento de chave, toque ou trackball é enviado para a atividade.
OnUserLeaveHint()	Chamado como parte do ciclo de vida da atividade quando uma atividade está prestes a entrar em segundo plano como resultado da escolha do usuário.
OnVisibleBehindCanceled()	Chamado quando uma atividade translúcida sobre essa atividade está se tornando opaca ou outra atividade está sendo iniciada.
OnWindowAttributesChanged(WindowManagerLayoutParams)	Isso é chamado sempre que os atributos da janela atual são alterados.
OnWindowFocusChanged(Boolean)	Chamado quando a corrente `Window` da atividade ganha ou perde o foco.
OnWindowStartingActionMode(ActionMode+ICallback, ActionModeType)	Chamado quando um modo de ação está sendo iniciado para esta janela.
OnWindowStartingActionMode(ActionMode+ICallback)	Dê à Atividade a chance de controlar a interface do usuário para um modo de ação solicitado pelo sistema.
OpenContextMenu(View)	Abre programaticamente o menu de contexto para um determinado `view`.
OpenFileInput(String)	Abra um arquivo privado associado ao pacote de aplicativos deste Contexto para leitura. (Herdado de ContextWrapper)
OpenFileOutput(String, FileCreationMode)	Abra um arquivo privado associado ao pacote de aplicativos deste Contexto para gravação. (Herdado de ContextWrapper)
OpenOptionsMenu()	Abre programaticamente o menu de opções.
OpenOrCreateDatabase(String, FileCreationMode, SQLiteDatabase+ICursorFactory, IDatabaseErrorHandler)	Abra um novo SQLiteDatabase privado associado ao pacote de aplicativos deste Contexto. (Herdado de ContextWrapper)
OpenOrCreateDatabase(String, FileCreationMode, SQLiteDatabase+ICursorFactory)	Abra um novo SQLiteDatabase privado associado ao pacote de aplicativos deste Contexto. (Herdado de ContextWrapper)
OverrideActivityTransition(OverrideTransition, Int32, Int32, Int32)	Personaliza a animação e a cor da tela de fundo para transições de atividade.
OverrideActivityTransition(OverrideTransition, Int32, Int32)	Personaliza a animação para transições de atividade.
OverridePendingTransition(Int32, Int32, Int32)	Chame imediatamente após um dos sabores de `#startActivity(Intent)` ou `#finish` para especificar uma animação de transição explícita a ser executada em seguida.
OverridePendingTransition(Int32, Int32)	Chame imediatamente após um dos sabores de `#startActivity(Intent)` ou `#finish` para especificar uma animação de transição explícita a ser executada em seguida.
PeekWallpaper()	Obsoleto. (Herdado de ContextWrapper)
PostponeEnterTransition()	Adie a transição de atividade de entrada quando a Atividade foi iniciada com `android.app.ActivityOptions#makeSceneTransitionAnimation(Activity, android.util.Pair[])`.
RebindService(IServiceConnection, Context+BindServiceFlags)	Revincular um serviço de aplicativo com sinalizadores de serviço de associação atualizados (Herdado de Context)
Recreate()	Faça com que essa atividade seja recriada com uma nova instância.
RegisterActivityLifecycleCallbacks(Application+IActivityLifecycleCallbacks)	Registre uma instância application.ActivityLifecycleCallbacks que recebe retornos de chamada do ciclo de vida apenas para esta Atividade.
RegisterComponentCallbacks(IComponentCallbacks)	Adicione um novo `ComponentCallbacks` à aplicação base do Contexto, que será chamado ao mesmo tempo que os métodos de atividades ComponentCallbacks e outros componentes são chamados. (Herdado de Context)
RegisterDeviceIdChangeListener(IExecutor, IIntConsumer)	Adiciona um novo ouvinte alterado da ID do `Context`dispositivo ao , que será chamado quando a associação do dispositivo for alterada pelo sistema. (Herdado de Context)
RegisterForContextMenu(View)	Registra um menu de contexto a ser mostrado para a exibição determinada (várias exibições podem mostrar o menu de contexto).
RegisterReceiver(BroadcastReceiver, IntentFilter, ActivityFlags)	Obsoleto. Registre-se para receber transmissões de intenção, com o receptor opcionalmente sendo exposto a Instant Apps. Consulte registerReceiver(BroadcastReceiver,IntentFilter) para obter mais informações. Por padrão, os Aplicativos Instantâneos não podem interagir com receptores em outros aplicativos, o que permite expor um receptor com o qual os Aplicativos Instantâneos podem interagir. Consulte BroadcastReceiver para obter mais informações sobre transmissões de intenção. A partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE, o sistema pode colocar transmissões registradas em contexto em uma fila enquanto o aplicativo está no estado armazenado em cache. Quando o aplicativo deixa o estado armazenado em cache, como retornar ao primeiro plano, o sistema entrega todas as transmissões na fila. Várias instâncias de determinadas transmissões podem ser mescladas em uma transmissão. A partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH, os receptores registrados com esse método respeitarão corretamente o Intent.setPackage(String) especificado para uma intenção que está sendo transmitida. Antes disso, ele seria ignorado e entregue a todos os receptores registrados correspondentes. Tenha cuidado ao usar isso para segurança. Receptor de parâmetros BroadcastReceiver: esse valor pode ser nulo. (Herdado de ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter, ReceiverFlags)	Registre-se para receber transmissões de intenção, com o receptor opcionalmente sendo exposto a Instant Apps. Consulte registerReceiver(BroadcastReceiver,IntentFilter) para obter mais informações. Por padrão, os Aplicativos Instantâneos não podem interagir com receptores em outros aplicativos, o que permite expor um receptor com o qual os Aplicativos Instantâneos podem interagir. Consulte BroadcastReceiver para obter mais informações sobre transmissões de intenção. A partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE, o sistema pode colocar transmissões registradas em contexto em uma fila enquanto o aplicativo está no estado armazenado em cache. Quando o aplicativo deixa o estado armazenado em cache, como retornar ao primeiro plano, o sistema entrega todas as transmissões na fila. Várias instâncias de determinadas transmissões podem ser mescladas em uma transmissão. A partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH, os receptores registrados com esse método respeitarão corretamente o Intent.setPackage(String) especificado para uma intenção que está sendo transmitida. Antes disso, ele seria ignorado e entregue a todos os receptores registrados correspondentes. Tenha cuidado ao usar isso para segurança. Receptor de parâmetros BroadcastReceiver: o BroadcastReceiver para lidar com a transmissão. Esse valor pode ser nulo. (Herdado de Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler, ActivityFlags)	Obsoleto. Registre-se para receber transmissões de intenção, para ser executado no contexto do agendador. Consulte registerReceiver(BroadcastReceiver,IntentFilter,int) e registerReceiver(BroadcastReceiver, IntentFilter, String,Handler) para obter mais informações. Consulte BroadcastReceiver para obter mais informações sobre transmissões de intenção. A partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE, o sistema pode colocar transmissões registradas em contexto em uma fila enquanto o aplicativo está no estado armazenado em cache. Quando o aplicativo deixa o estado armazenado em cache, como retornar ao primeiro plano, o sistema entrega todas as transmissões na fila. Várias instâncias de determinadas transmissões podem ser mescladas em uma transmissão. A partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH, os receptores registrados com esse método respeitarão corretamente o Intent.setPackage(String) especificado para uma intenção que está sendo transmitida. Antes disso, ele seria ignorado e entregue a todos os receptores registrados correspondentes. Tenha cuidado ao usar isso para segurança. Receptor de parâmetros BroadcastReceiver: esse valor pode ser nulo. (Herdado de ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler, ReceiverFlags)	Registre-se para receber transmissões de intenção, para ser executado no contexto do agendador. Consulte registerReceiver(BroadcastReceiver,IntentFilter,int) e registerReceiver(BroadcastReceiver, IntentFilter, String,Handler) para obter mais informações. Consulte BroadcastReceiver para obter mais informações sobre transmissões de intenção. A partir de Build.VERSION_CODES. UPSIDE_DOWN_CAKE, o sistema pode colocar transmissões registradas em contexto em uma fila enquanto o aplicativo está no estado armazenado em cache. Quando o aplicativo deixa o estado armazenado em cache, como retornar ao primeiro plano, o sistema entrega todas as transmissões na fila. Várias instâncias de determinadas transmissões podem ser mescladas em uma transmissão. A partir de Build.VERSION_CODES. ICE_CREAM_SANDWICH, os receptores registrados com esse método respeitarão corretamente o Intent.setPackage(String) especificado para uma intenção que está sendo transmitida. Antes disso, ele seria ignorado e entregue a todos os receptores registrados correspondentes. Tenha cuidado ao usar isso para segurança. Receptor de parâmetros BroadcastReceiver: o BroadcastReceiver para lidar com a transmissão. (Herdado de Context)
RegisterReceiver(BroadcastReceiver, IntentFilter, String, Handler)	Registre-se para receber transmissões de intenção, a serem executadas no contexto do <agendador>< var/var>. (Herdado de ContextWrapper)
RegisterReceiver(BroadcastReceiver, IntentFilter)	Registre um BroadcastReceiver para ser executado no thread de atividade principal. (Herdado de ContextWrapper)
RegisterScreenCaptureCallback(IExecutor, Activity+IScreenCaptureCallback)	Registra um retorno de chamada de captura de tela para essa atividade.
ReleaseInstance()	Peça que a instância do aplicativo local dessa atividade seja liberada para liberar sua memória.
RemoveDialog(Int32)	Obsoleto. Remove todas as referências internas a uma caixa de diálogo gerenciada por essa Atividade.
RemoveStickyBroadcast(Intent)	Obsoleto. (Herdado de ContextWrapper)
RemoveStickyBroadcastAsUser(Intent, UserHandle)	Obsoleto. (Herdado de ContextWrapper)
ReportFullyDrawn()	Informe ao sistema que seu aplicativo agora está totalmente desenhado, para fins de diagnóstico e otimização.
RequestDragAndDropPermissions(DragEvent)	Criar `DragAndDropPermissions` objeto associado a essa atividade e controlar as permissões de acesso para URIs de conteúdo associadas ao `DragEvent`.
RequestFullscreenMode(FullscreenModeRequest, IOutcomeReceiver)	Solicitação para colocar a atividade na tela inteira.
RequestOpenInBrowserEducation()	Solicitações para mostrar a educação "Abrir no navegador".
RequestPermissions(String[], Int32, Int32)	Solicita permissões a serem concedidas a este aplicativo.
RequestPermissions(String[], Int32)	Solicita permissões a serem concedidas a este aplicativo.
RequestShowKeyboardShortcuts()	Solicite que a tela Atalhos de Teclado apareça.
RequestVisibleBehind(Boolean)	As atividades que desejam permanecer visíveis atrás de uma atividade translúcida acima delas devem chamar esse método a qualquer momento entre o início `#onResume()` e o retorno de `#onPause()`.
RequestWindowFeature(WindowFeatures)	Habilitar recursos de janela estendida.
RequireViewById(Int32)	Localiza uma exibição que foi identificada pelo `android:id` atributo XML que foi processado `#onCreate`ou lança uma IllegalArgumentException se a ID for inválida ou se não houver nenhuma exibição correspondente na hierarquia.
RequireViewById<T>(Int32)
RevokeSelfPermissionOnKill(String)	Dispara a revogação assíncrona de uma permissão de runtime. (Herdado de Context)
RevokeSelfPermissionsOnKill(ICollection<String>)	Dispara a revogação de uma ou mais permissões para o pacote de chamada. (Herdado de Context)
RevokeUriPermission(String, Uri, ActivityFlags)	Remova permissões para acessar um Uri de provedor de conteúdo específico que foi adicionado anteriormente com grantUriPermission(String, Uri, int) para um pacote de destino específico. O Uri fornecido corresponderá a todos os Uris concedidos anteriormente que são iguais ou um sub-caminho do Uri fornecido. Ou seja, revogar "content://foo/target" revogará "content://foo/target" e "content://foo/target/sub", mas não "content://foo". Ele não removerá quaisquer concessões de prefixo que existam em um nível mais alto. Ao contrário de revokeUriPermission(Uri,int), esse método só revogará permissões que foram explicitamente concedidas por meio de grantUriPermission(String, Uri, int) e somente para o pacote especificado. Quaisquer concessões correspondentes que tenham ocorrido por meio de outros mecanismos (área de transferência, inicialização de atividades, início do serviço etc) não serão removidas. (Herdado de ContextWrapper)
RevokeUriPermission(Uri, ActivityFlags)	Remova todas as permissões para acessar um Uri de provedor de conteúdo específico que foram adicionados anteriormente com M:Android.Content.Context.GrantUriPermission(System.String, Android.Net.Uri,Android.Net.Uri). (Herdado de ContextWrapper)
RunOnUiThread(Action)
RunOnUiThread(IRunnable)	Executa a ação especificada no thread da interface do usuário.
SendBroadcast(Intent, String, Bundle)	Difunda a intenção determinada para todos os BroadcastReceivers interessados, permitindo que uma permissão opcional necessária seja imposta. (Herdado de Context)
SendBroadcast(Intent, String)	Difunda a intenção determinada para todos os BroadcastReceivers interessados, permitindo que uma permissão opcional necessária seja imposta. (Herdado de ContextWrapper)
SendBroadcast(Intent)	Difunda a intenção determinada para todos os BroadcastReceivers interessados. (Herdado de ContextWrapper)
SendBroadcastAsUser(Intent, UserHandle, String)	A versão permite SendBroadcast(Intent, String) que você especifique o usuário para o qual a transmissão será enviada. (Herdado de ContextWrapper)
SendBroadcastAsUser(Intent, UserHandle)	A versão permite SendBroadcast(Intent) que você especifique o usuário para o qual a transmissão será enviada. (Herdado de ContextWrapper)
SendBroadcastWithMultiplePermissions(Intent, String[])	Difunda a intenção determinada para todos os BroadcastReceivers interessados, permitindo que uma matriz de permissões necessárias seja imposta. (Herdado de Context)
SendOrderedBroadcast(Intent, Int32, String, String, BroadcastReceiver, Handler, String, Bundle, Bundle)	Transmite uma intenção para receptores interessados em ordem. (Herdado de ContextWrapper)
SendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, Result, String, Bundle)	A versão dessa SendBroadcast(Intent) versão permite que você receba dados de volta da transmissão. (Herdado de ContextWrapper)
SendOrderedBroadcast(Intent, String, Bundle, BroadcastReceiver, Handler, Result, String, Bundle)	A versão dessa `#sendBroadcast(Intent)` versão permite que você receba dados de volta da transmissão. (Herdado de Context)
SendOrderedBroadcast(Intent, String, Bundle)	Difunda a intenção determinada para todos os BroadcastReceivers interessados, entregando-os um de cada vez para permitir que receptores mais preferenciais consumam a transmissão antes que ela seja entregue a receptores menos preferenciais. (Herdado de Context)
SendOrderedBroadcast(Intent, String, String, BroadcastReceiver, Handler, Result, String, Bundle)	A versão permite `#sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle)` que você especifique a Operação de Aplicativo para impor restrições em quais receptores a transmissão será enviada. (Herdado de Context)
SendOrderedBroadcast(Intent, String)	Difunda a intenção determinada para todos os BroadcastReceivers interessados, entregando-os um de cada vez para permitir que receptores mais preferenciais consumam a transmissão antes que ela seja entregue a receptores menos preferenciais. Essa chamada é assíncrona; ele retorna imediatamente e você continuará em execução enquanto os receptores são executados. Consulte BroadcastReceiver para obter mais informações sobre transmissões de intenção. (Herdado de ContextWrapper)
SendOrderedBroadcastAsUser(Intent, UserHandle, String, BroadcastReceiver, Handler, Result, String, Bundle)	Versão de sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int,String,Bundle) que permite especificar ao usuário para o qual a transmissão será enviada. Isso não está disponível para aplicativos que não estão pré-instalados na imagem do sistema. Consulte BroadcastReceiver para obter mais informações sobre transmissões de intenção. Requer android. Manifest.permission.INTERACT_ACROSS_USERS (Herdado de ContextWrapper)
SendStickyBroadcast(Intent, Bundle)	Execute um `#sendBroadcast(Intent)` que seja "autoadesiva", o que significa que a intenção que você está enviando permanece após a conclusão da transmissão, para que outras pessoas possam recuperar rapidamente esses dados por meio do valor retornado de `#registerReceiver(BroadcastReceiver, IntentFilter)`. (Herdado de Context)
SendStickyBroadcast(Intent)	Obsoleto. Execute um `#sendBroadcast(Intent)` que seja "autoadesiva", o que significa que a intenção que você está enviando permanece após a conclusão da transmissão, para que outras pessoas possam recuperar rapidamente esses dados por meio do valor retornado de `#registerReceiver(BroadcastReceiver, IntentFilter)`. (Herdado de ContextWrapper)
SendStickyBroadcastAsUser(Intent, UserHandle)	Obsoleto. (Herdado de ContextWrapper)
SendStickyOrderedBroadcast(Intent, BroadcastReceiver, Handler, Result, String, Bundle)	Obsoleto. (Herdado de ContextWrapper)
SendStickyOrderedBroadcastAsUser(Intent, UserHandle, BroadcastReceiver, Handler, Result, String, Bundle)	Obsoleto. (Herdado de ContextWrapper)
SetActionBar(Toolbar)	Defina um `android.widget.Toolbar Toolbar` para atuar como a `ActionBar` janela atividade.
SetAllowCrossUidActivitySwitchFromBelow(Boolean)	Especifica se as atividades abaixo desta na tarefa também podem iniciar outras atividades ou concluir a tarefa.
SetContentView(Int32)	Defina o conteúdo da atividade de um recurso de layout.
SetContentView(View, ViewGroup+LayoutParams)	Defina o conteúdo da atividade como uma exibição explícita.
SetContentView(View)	Defina o conteúdo da atividade como uma exibição explícita.
SetDefaultKeyMode(DefaultKey)	Selecione o tratamento de chave padrão para essa atividade.
SetEnterSharedElementCallback(SharedElementCallback)	Quando `android.app.ActivityOptions#makeSceneTransitionAnimation(Activity, android.view.View, String)` foi usado para iniciar uma Atividade, <o var>callback</var> será chamado para manipular elementos compartilhados na Atividade iniciada .
SetExitSharedElementCallback(SharedElementCallback)	Quando `android.app.ActivityOptions#makeSceneTransitionAnimation(Activity, android.view.View, String)` foi usado para iniciar uma Atividade, <o var>callback</var> será chamado para lidar com elementos compartilhados na Atividade de inicialização .
SetFeatureDrawable(WindowFeatures, Drawable)	Conveniência para chamar `android.view.Window#setFeatureDrawable(int, Drawable)`.
SetFeatureDrawableAlpha(WindowFeatures, Int32)	Conveniência para chamar `android.view.Window#setFeatureDrawableAlpha`.
SetFeatureDrawableResource(WindowFeatures, Int32)	Conveniência para chamar `android.view.Window#setFeatureDrawableResource`.
SetFeatureDrawableUri(WindowFeatures, Uri)	Conveniência para chamar `android.view.Window#setFeatureDrawableUri`.
SetFinishOnTouchOutside(Boolean)	Define se essa atividade foi concluída quando tocada fora dos limites de sua janela.
SetHandle(IntPtr, JniHandleOwnership)	Define a propriedade Handle (Herdado de Object)
SetHandoffEnabled(Boolean, HandoffActivityParams)	Define se o Handoff está habilitado para essa Atividade.
SetInheritShowWhenLocked(Boolean)	Especifica se isso `Activity` deve ser mostrado na parte superior da tela de bloqueio sempre que a tela de bloqueio estiver ativada e essa atividade tiver outra atividade por trás dela com o conjunto de atributos showWhenLock.
SetIntent(Intent, ComponentCaller)	Altera a intenção retornada por `#getIntent`, e ComponentCaller retornado por `#getCaller`.
SetLocusContext(LocusId, Bundle)	Define o `android.content.LocusId` para essa atividade.
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
SetPersistent(Boolean)	Este membro foi preterido.
SetPictureInPictureParams(PictureInPictureParams)	Atualiza as propriedades da atividade de imagem na imagem ou define-a para ser usada posteriormente quando `#enterPictureInPictureMode()` for chamada.
SetProgress(Int32)	Obsoleto. Define o progresso das barras de progresso no título.
SetProgressBarIndeterminate(Boolean)	Obsoleto. Define se a barra de progresso horizontal no título deve ser indeterminada (a circular é sempre indeterminado).
SetProgressBarIndeterminateVisibility(Boolean)	Obsoleto. Define a visibilidade da barra de progresso indeterminado no título.
SetProgressBarVisibility(Boolean)	Obsoleto. Define a visibilidade da barra de progresso no título.
SetRecentsScreenshotEnabled(Boolean)	Se definido como false, isso indica ao sistema que ele nunca deve fazer uma captura de tela da atividade a ser usada como uma representação na tela recente.
SetResult(Result, Intent)	Chame isso para definir o resultado que sua atividade retornará ao chamador.
SetResult(Result)	Chame isso para definir o resultado que sua atividade retornará ao chamador.
SetSecondaryProgress(Int32)	Obsoleto. Define o progresso secundário da barra de progresso no título.
SetShouldDockBigOverlays(Boolean)	Especifica uma preferência para encaixar grandes sobreposições, como a imagem expandida em imagem na TV (consulte `PictureInPictureParams.Builder#setExpandedAspectRatio`).
SetShowWhenLocked(Boolean)	Especifica se um `Activity` deve ser mostrado na parte superior da tela de bloqueio sempre que a tela de bloqueio estiver ativada e a atividade for retomada.
SetTaskDescription(ActivityManager+TaskDescription)	Define informações que descrevem a tarefa com essa atividade para apresentação dentro da interface do usuário do sistema Recents.
SetTheme(Int32)	Defina o tema base para esse contexto. (Herdado de ContextWrapper)
SetTheme(Resources+Theme)	Defina a configuração do tema atual. (Herdado de ContextThemeWrapper)
SetTitle(Int32)	Altere o título associado a essa atividade.
SetTranslucent(Boolean)	Converta uma atividade, particularmente com `android.R.attr#windowIsTranslucent` ou `android.R.attr#windowIsFloating` atributo, em uma atividade opaca de tela inteira ou converta-a de opaca de volta para translúcida.
SetTurnScreenOn(Boolean)	Especifica se a tela deve ser ativada quando a `Activity` tela é retomada.
SetVisible(Boolean)	Controle se a janela principal dessa atividade está visível.
SetVrModeEnabled(Boolean, ComponentName)	Habilitar ou desabilitar o modo VR (realidade virtual) para essa Atividade.
SetWallpaper(Bitmap)	Obsoleto. (Herdado de ContextWrapper)
SetWallpaper(Stream)	Obsoleto. (Herdado de ContextWrapper)
ShouldDockBigOverlays()	Retorna se grandes sobreposições devem ser encaixadas ao lado da atividade, conforme definido por `#setShouldDockBigOverlays`.
ShouldShowRequestPermissionRationale(String, Int32)	Obtém se você deve mostrar a interface do usuário com lógica antes de solicitar uma permissão.
ShouldShowRequestPermissionRationale(String)	Obtém se você deve mostrar a interface do usuário com lógica antes de solicitar uma permissão.
ShouldUpRecreateTask(Intent)	Retornará true se o aplicativo deve recriar a tarefa ao navegar 'para cima' dessa atividade usando targetIntent.
ShowAssist(Bundle)	Peça para que o assistente atual seja mostrado ao usuário.
ShowDialog(Int32, Bundle)	Obsoleto. Mostrar uma caixa de diálogo gerenciada por essa atividade.
ShowDialog(Int32)	Obsoleto. Uma versão `#showDialog(int, Bundle)` simples disso não aceita argumentos.
ShowLockTaskEscapeMessage()	Mostra ao usuário a mensagem definida pelo sistema para dizer ao usuário como sair do modo de tarefa de bloqueio.
StartActionMode(ActionMode+ICallback, ActionModeType)	Inicie um modo de ação do tipo fornecido.
StartActionMode(ActionMode+ICallback)	Inicie um modo de ação do tipo padrão ActionMode.TYPE_PRIMARY.
StartActivities(Intent[], Bundle)	Inicie várias novas atividades. (Herdado de ContextWrapper)
StartActivities(Intent[])	O mesmo que StartActivities(Intent[], Bundle) sem opções especificadas. (Herdado de ContextWrapper)
StartActivity(Intent, Bundle)	Inicie uma nova atividade. (Herdado de ContextWrapper)
StartActivity(Intent)	O mesmo que StartActivity(Intent, Bundle) sem opções especificadas. (Herdado de ContextWrapper)
StartActivity(Type)	O mesmo que startActivity(Intent,Bundle) sem opções especificadas. (Herdado de Context)
StartActivityForResult(Intent, Int32, Bundle)	Inicie uma atividade para a qual você gostaria de obter um resultado quando terminar.
StartActivityForResult(Intent, Int32)	O mesmo que chamar `#startActivityForResult(Intent, int, Bundle)` sem opções.
StartActivityForResult(Type, Int32)	Inicia uma atividade do tipo gerenciado especificado e solicita um resultado.
StartActivityFromChild(Activity, Intent, Int32, Bundle)	Isso é chamado quando uma atividade filho deste chama seu `#startActivity` método ou `#startActivityForResult` método.
StartActivityFromChild(Activity, Intent, Int32)	O mesmo que chamar `#startActivityFromChild(Activity, Intent, int, Bundle)` sem opções.
StartActivityFromFragment(Fragment, Intent, Int32, Bundle)	Isso é chamado quando um fragmento nessa atividade chama seu `Fragment#startActivity` método ou `Fragment#startActivityForResult` método.
StartActivityFromFragment(Fragment, Intent, Int32)	O mesmo que chamar `#startActivityFromFragment(Fragment, Intent, int, Bundle)` sem opções.
StartActivityIfNeeded(Intent, Int32, Bundle)	Uma variação especial para iniciar uma atividade somente se uma nova instância de atividade for necessária para lidar com a intenção fornecida.
StartActivityIfNeeded(Intent, Int32)	O mesmo que chamar `#startActivityIfNeeded(Intent, int, Bundle)` sem opções.
StartForegroundService(Intent)	Semelhante a startService(Intent), mas com uma promessa implícita de que o Serviço chamará startForeground(int, android.app.Notification) quando ele começar a ser executado. O serviço recebe uma quantidade de tempo comparável ao intervalo ANR para fazer isso, caso contrário, o sistema falhará automaticamente no processo, caso em que uma exceção interna ForegroundServiceDidNotStartInTimeException é registrada em logcat em dispositivos que executam a versão do SDK Build.VERSION_CODES. S ou posterior. Em versões mais antigas do Android, uma exceção interna RemoteServiceException é registrada em vez disso, com uma mensagem correspondente. Ao contrário do startService(Intent) comum, esse método pode ser usado a qualquer momento, independentemente de o aplicativo que hospeda o serviço estar em um estado de primeiro plano. Observação: começando com a versão do SDK Build.VERSION_CODES. S, aplicativos direcionados à versão do SDK Build.VERSION_CODES. S ou superior não têm permissão para iniciar serviços em primeiro plano em segundo plano. Veja as alterações de comportamento: aplicativos direcionados ao Android 12 para obter mais detalhes. (Herdado de ContextWrapper)
StartInstrumentation(ComponentName, String, Bundle)	Comece a executar uma Instrumentation classe. (Herdado de ContextWrapper)
StartIntentSender(IntentSender, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Tipo StartActivity(Intent, Bundle), mas tomando um IntentSender para começar. (Herdado de ContextWrapper)
StartIntentSender(IntentSender, Intent, ActivityFlags, ActivityFlags, Int32)	O mesmo que startIntentSender(IntentSender, Intent, int, int, int,Bundle) sem opções especificadas. (Herdado de ContextWrapper)
StartIntentSenderForResult(IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Como `#startActivityForResult(Intent, int)`, mas permitindo que você use um IntentSender para descrever a atividade a ser iniciada.
StartIntentSenderForResult(IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32)	O mesmo que chamar `#startIntentSenderForResult(IntentSender, int, Intent, int, int, int, Bundle)` sem opções.
StartIntentSenderFromChild(Activity, IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32, Bundle)	Like `#startActivityFromChild(Activity, Intent, int)`, but taking a IntentSender; see `#startIntentSenderForResult(IntentSender, int, Intent, int, int, int)` para mais informações.
StartIntentSenderFromChild(Activity, IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32)	O mesmo que chamar `#startIntentSenderFromChild(Activity, IntentSender, int, Intent, int, int, int, Bundle)` sem opções.
StartLocalVoiceInteraction(Bundle)	Inicia uma sessão de interação de voz local.
StartLockTask()	Solicite colocar essa atividade em um modo em que o usuário esteja bloqueado para um conjunto restrito de aplicativos.
StartManagingCursor(ICursor)	Obsoleto. Esse método permite que a atividade cuide do gerenciamento `Cursor`do ciclo de vida determinado para você com base no ciclo de vida da atividade.
StartNextMatchingActivity(Intent, Bundle)	Versão especial do início de uma atividade, para uso quando você estiver substituindo outros componentes de atividade.
StartNextMatchingActivity(Intent)	O mesmo que chamar `#startNextMatchingActivity(Intent, Bundle)` sem opções.
StartPostponedEnterTransition()	Inicie as transições adiadas após `#postponeEnterTransition()` a chamada.
StartSearch(String, Boolean, Bundle, Boolean)	Esse gancho é chamado para iniciar a interface do usuário de pesquisa.
StartService(Intent)	Solicite que um determinado serviço de aplicativo seja iniciado. (Herdado de ContextWrapper)
StopLocalVoiceInteraction()	Solicitação para encerrar a interação de voz atual que foi iniciada anteriormente usando `#startLocalVoiceInteraction(Bundle)`.
StopLockTask()	Impeça que a tarefa atual seja bloqueada.
StopManagingCursor(ICursor)	Obsoleto. Dado um Cursor que foi dado anteriormente, `#startManagingCursor`interrompa o gerenciamento da atividade desse cursor.
StopService(Intent)	Solicite que um determinado serviço de aplicativo seja interrompido. (Herdado de ContextWrapper)
TakeKeyEvents(Boolean)	Solicite que os principais eventos cheguem a essa atividade.
ToArray<T>()	Cria uma matriz gerenciada com base nesse wrapper de matriz Java. (Herdado de Object)
ToString()	Retorna uma representação de cadeia de caracteres do objeto. (Herdado de Object)
TriggerSearch(String, Bundle)	Semelhante a `#startSearch`, mas, na verdade, aciona a consulta de pesquisa depois de invocar a caixa de diálogo de pesquisa.
UnbindService(IServiceConnection)	Desconecte-se de um serviço de aplicativo. (Herdado de ContextWrapper)
UnregisterActivityLifecycleCallbacks(Application+IActivityLifecycleCallbacks)	Cancelar o registro de um Application.ActivityLifecycleCallbacks registrado anteriormente com registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks).
UnregisterComponentCallbacks(IComponentCallbacks)	Remova um `ComponentCallbacks` objeto que foi registrado anteriormente com `#registerComponentCallbacks(ComponentCallbacks)`. (Herdado de Context)
UnregisterDeviceIdChangeListener(IIntConsumer)	Remove um ouvinte alterado da ID do dispositivo do Contexto. (Herdado de Context)
UnregisterForContextMenu(View)	Impede que um menu de contexto seja mostrado para o modo de exibição fornecido.
UnregisterFromRuntime()	Cancela o registro desse par Java do runtime de interoperabilidade. (Herdado de Object)
UnregisterReceiver(BroadcastReceiver)	Cancelar o registro de um BroadcastReceiver registrado anteriormente. (Herdado de ContextWrapper)
UnregisterScreenCaptureCallback(Activity+IScreenCaptureCallback)	Cancela o registro de um retorno de chamada de captura de tela para essa superfície.
UpdateServiceBindings(ICollection<Context.UpdateBindingParams>)	Execute uma atualização em lote de associações existentes. (Herdado de Context)
UpdateServiceGroup(IServiceConnection, Int32, Int32)	Para um serviço anteriormente associado `#bindService` a ou a um método relacionado, altere como o sistema gerencia o processo desse serviço em relação a outros processos. (Herdado de Context)
Wait()	Faz com que o thread atual aguarde até ser despertado, normalmente por ser <notificado/em> ou <em>interrompido</em>.<> (Herdado de Object)
Wait(Int64, Int32)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente por ser <>notificado</em> ou <em>interrompido</em>, ou até que uma determinada quantidade de tempo real tenha decorrido. (Herdado de Object)
Wait(Int64)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente por ser <>notificado</em> ou <em>interrompido</em>, ou até que uma determinada quantidade de tempo real tenha decorrido. (Herdado de Object)

Implantações explícitas de interface

Nome	Description
IJavaPeerable.Disposed()	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
IJavaPeerable.Finalized()	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)	Uma atividade é uma única coisa focada que o usuário pode fazer. (Herdado de JavaObject)
IJavaPeerable.UnregisterFromRuntime()	Uma atividade é uma única coisa focada que o usuário pode fazer.

Métodos de Extensão

Nome	Description
GetJniTypeName(IJavaPeerable)	Obtém o nome JNI do tipo da instância `self`.
JavaAs<TResult>(IJavaPeerable)	Tente coagir a digitar `selfTResult`, verificando se a coerção é válida no lado Java.
JavaCast<TResult>(IJavaObject)	Executa uma conversão de tipo marcada por runtime do Android.
JavaCast<TResult>(IJavaObject)	Uma atividade é uma única coisa focada que o usuário pode fazer.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Tente coagir a digitar `selfTResult`, verificando se a coerção é válida no lado Java.

Aplica-se a