Fragment Classe
Definição
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.
Essa classe foi preterida no nível 28 da API.
[Android.Runtime.Register("android/app/Fragment", DoNotGenerateAcw=true)]
public class Fragment : Java.Lang.Object, Android.Content.IComponentCallbacks2, Android.Views.View.IOnCreateContextMenuListener, IDisposable[<Android.Runtime.Register("android/app/Fragment", DoNotGenerateAcw=true)>]
type Fragment = class
inherit Object
interface IComponentCallbacks2
interface IComponentCallbacks
interface IJavaObject
interface IDisposable
interface IJavaPeerable
interface View.IOnCreateContextMenuListener- Herança
- Derivado
- Atributos
- Implementações
Comentários
Essa classe foi preterida no nível 28 da API. Use o Fragmento da Biblioteca de Fragmentos do Jetpack para comportamento consistente em todos os dispositivos e acesso ao Ciclo de Vida.
Um Fragmento é uma parte da interface do usuário de um aplicativo ou comportamento que pode ser colocado em uma atividade. A interação com fragmentos é feita por meio do FragmentManager, que pode ser obtido por meio de Activity.getFragmentManager() e Fragment.getFragmentManager(). A classe Fragment pode ser usada de várias maneiras para obter uma ampla variedade de resultados. Em seu núcleo, ele representa uma determinada operação ou interface que está em execução dentro de uma atividade maior. Um fragmento está intimamente vinculado à atividade em que está e não pode ser usado além de um. Embora o Fragmento defina seu próprio ciclo de vida, esse ciclo de vida depende de sua atividade: se a atividade for interrompida, nenhum fragmento dentro dele poderá ser iniciado; quando a atividade for destruída, todos os fragmentos serão destruídos. Todas as subclasses de Fragment devem incluir um construtor público sem argumento. A estrutura geralmente ressociará uma classe de fragmento quando necessário, especialmente durante a restauração de estado, e precisa ser capaz de encontrar esse construtor para instanciá-la. Se o construtor sem argumento não estiver disponível, uma exceção de runtime ocorrerá em alguns casos durante a restauração de estado. Tópicos abordados aqui: Guias do desenvolvedor do layout de ciclo de vida de plataformas mais antigas para obter mais informações sobre como usar fragmentos, leia o guia do desenvolvedor de Fragmentos.
Embora o ciclo de vida de um fragmento esteja ligado à sua atividade de propriedade, ele tem sua própria ruga no ciclo de vida da atividade padrão. Ele inclui métodos básicos de ciclo de vida de atividade, como onResume(), mas também são importantes métodos relacionados a interações com a atividade e a geração da interface do usuário. A série principal de métodos de ciclo de vida que são chamados para elevar um fragmento ao estado retomado (interagindo com o usuário) são: onAttach(Activity) chamado depois que o fragmento é associado à sua atividade. onCreate(Bundle) chamado para fazer a criação inicial do fragmento. onCreateView(LayoutInflater, ViewGroup, Bundle) cria e retorna a hierarquia de exibição associada ao fragmento. onActivityCreated(Bundle) informa ao fragmento que sua atividade concluiu sua própria Atividade.onCreate(). onViewStateRestored(Bundle) informa ao fragmento que todo o estado salvo de sua hierarquia de exibição foi restaurado. onStart() torna o fragmento visível para o usuário (com base em sua atividade que está sendo iniciada). onResume() faz com que o fragmento comece a interagir com o usuário (com base em sua atividade que está sendo retomada). Como um fragmento não está mais sendo usado, ele passa por uma série inversa de retornos de chamada: o fragmento onPause() não está mais interagindo com o usuário, seja porque sua atividade está sendo pausada ou uma operação de fragmento está modificando-a na atividade. O fragmento onStop() não está mais visível para o usuário porque sua atividade está sendo interrompida ou uma operação de fragmento está modificando-a na atividade. onDestroyView() permite que o fragmento limpe os recursos associados à exibição. onDestroy() chamado para fazer a limpeza final do estado do fragmento. onDetach() chamado imediatamente antes do fragmento não estar mais associado à sua atividade. Os Fragmentos de Layout podem ser usados como parte do layout do aplicativo, permitindo que você modularize melhor seu código e ajuste mais facilmente sua interface do usuário para a tela em que ele está sendo executado. Como exemplo, podemos examinar um programa simples que consiste em uma lista de itens e exibir os detalhes de cada item.
O XML de layout de uma atividade pode incluir <marcas de fragmento> para inserir instâncias de fragmento dentro do layout. Por exemplo, aqui está um layout simples que insira um fragmento:
O layout é instalado na atividade da maneira normal:
O fragmento de títulos, mostrando uma lista de títulos, é bastante simples, contando com ListFragment para a maior parte de seu trabalho. Observe a implementação de clicar em um item: dependendo do layout da atividade atual, ele pode criar e exibir um novo fragmento para mostrar os detalhes in-loco (mais sobre isso posteriormente) ou iniciar uma nova atividade para mostrar os detalhes.
O fragmento de detalhes mostrando o conteúdo de um item selecionado apenas exibe uma cadeia de caracteres de texto com base em um índice de uma matriz de cadeia de caracteres interna no aplicativo:
Nesse caso, quando o usuário clica em um título, não há nenhum contêiner de detalhes na atividade atual, portanto, o código de clique do fragmento de títulos iniciará uma nova atividade para exibir o fragmento de detalhes:
No entanto, a tela pode ser grande o suficiente para mostrar a lista de títulos e detalhes sobre o título selecionado no momento. Para usar esse layout em uma tela paisagem, esse layout alternativo pode ser colocado em layout-terra:
Observe como o código anterior se ajustará a esse fluxo de interface do usuário alternativo: o fragmento de títulos agora inserirá o fragmento de detalhes dentro dessa atividade e a atividade de detalhes será concluída se estiver em execução em uma configuração em que os detalhes possam ser mostrados no local. Quando uma alteração de configuração faz com que a atividade que hospeda esses fragmentos seja reiniciada, sua nova instância poderá usar um layout diferente que não inclua os mesmos fragmentos do layout anterior. Nesse caso, todos os fragmentos anteriores ainda serão instanciados e executados na nova instância. No entanto, qualquer um que não esteja mais associado a uma <marca de fragmento> na hierarquia de exibição não terá sua exibição de conteúdo criada e retornará false de isInLayout(). (O código aqui também mostra como você pode determinar se um fragmento colocado em um contêiner não está mais em execução em um layout com esse contêiner e evitar a criação de sua hierarquia de exibição nesse caso.) Os atributos da <marca de fragmento> são usados para controlar os LayoutParams fornecidos ao anexar a exibição do fragmento ao contêiner pai. Eles também podem ser analisados pelo fragmento em onInflate(Activity, AttributeSet, Bundle) como parâmetros. O fragmento que está sendo instanciado deve ter algum tipo de identificador exclusivo para que possa ser associado novamente a uma instância anterior se a atividade pai precisar ser destruída e recriada. Isso pode ser fornecido destas maneiras: se nada for fornecido explicitamente, a ID de exibição do contêiner será usada. android:tag pode ser usado em <fragmento> para fornecer um nome de marca específico para o fragmento. android:id pode ser usado em <fragmento> para fornecer um identificador específico para o fragmento. Back Stack A transação na qual os fragmentos são modificados pode ser colocada em uma pilha de back-stack interna da atividade proprietária. Quando o usuário pressiona novamente a atividade, todas as transações na pilha traseira são exibidas antes que a atividade em si seja concluída. Por exemplo, considere esse fragmento simples que é instanciado com um argumento inteiro e exibe isso em um TextView em sua interface do usuário:
Uma função que cria uma nova instância do fragmento, substituindo qualquer instância de fragmento atual que está sendo mostrada e empurrando essa alteração para a pilha traseira pode ser gravada como: Depois de cada chamada para essa função, uma nova entrada está na pilha e pressionar novamente a colocará para retornar o usuário para qualquer estado anterior em que a interface do usuário da atividade estava. Fragmentos que aparecem ou desaparecem não geram eventos do sistema para acessibilidade, portanto, defina um título em seus fragmentos com View.setAccessibilityPaneTitle(CharSequence) para notificar os usuários de acessibilidade dessas transições de interface do usuário.
Referência do Android para android.app.Fragment.
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 |
|---|---|
| Fragment() |
Construtor padrão. |
| Fragment(IntPtr, JniHandleOwnership) |
Inicializa uma representação gerenciada de um objeto de interface nativa Java existente. |
Propriedades
| Nome | Description |
|---|---|
| Activity |
Retorne a atividade à qual este fragmento está associado no momento. |
| AllowEnterTransitionOverlap |
Retorna se a transição de saída e a transição de entrada se sobrepõem ou não. |
| AllowReturnTransitionOverlap |
Retorna se a transição de retorno e a transição de recuo se sobrepõem ou não. |
| Arguments |
Retorne os argumentos fornecidos para setArguments(Bundle), se houver. |
| ChildFragmentManager |
Retorne um FragmentManager privado para colocar e gerenciar fragmentos dentro deste Fragmento. |
| Class |
Retorna a classe de runtime deste |
| Context |
Retorne o Contexto ao qual este fragmento está associado no momento. |
| EnterTransition |
Retorna a Transição que será usada para mover Exibições para a cena inicial. |
| ExitTransition |
Retorna a Transição que será usada para mover Exibições para fora da cena quando o fragmento for removido, oculto ou desanexado ao não estourar a pilha traseira. |
| FragmentManager |
Retorne o FragmentManager para interagir com fragmentos associados à atividade desse fragmento. |
| Handle |
O identificador para a instância subjacente do Android. (Herdado de Object) |
| Host |
Retorne o objeto host deste fragmento. |
| Id |
Retorne o identificador pelo qual esse fragmento é conhecido. |
| IsAdded |
Retornará true se o fragmento for adicionado atualmente à sua atividade. |
| IsDetached |
Retornará true se o fragmento tiver sido explicitamente desanexado da interface do usuário. |
| IsHidden |
Retornará true se o fragmento estiver oculto. |
| IsInLayout |
Retornará true se o layout for incluído como parte de uma hierarquia de exibição de atividade por meio da marca de <fragmento> . |
| IsRemoving |
Retornará true se esse fragmento estiver sendo removido de sua atividade no momento. |
| IsResumed |
Retornará true se o fragmento estiver no estado retomado. |
| IsStateSaved |
Retornará true se esse fragmento for adicionado e seu estado já tiver sido salvo pelo host. |
| IsVisible |
Retornará true se o fragmento estiver visível no momento para o usuário. |
| JniIdentityHashCode |
Obtém o código de hash de identidade atribuído a esse par Java pelo runtime de interoperabilidade. (Herdado de Object) |
| JniManagedPeerState |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| JniPeerMembers |
Fornece infraestrutura de associação JNI para Android.App.Fragment. |
| LayoutInflater |
Retorna o LayoutInflater armazenado em cache usado para inflar exibições desse fragmento. |
| LoaderManager |
Esse método é preterido. |
| ParentFragment |
Retorna o fragmento pai que contém este fragmento. |
| PeerReference |
Obtém a referência de objeto JNI para este par Java. (Herdado de Object) |
| ReenterTransition |
Retorna a Transição que será usada para mover Exibições para a cena ao retornar devido ao estouro de uma pilha traseira. |
| Resources |
Retornar getActivity().getResources(). |
| RetainInstance |
Controlar se uma instância de fragmento é retida na recriação da atividade (como de uma alteração de configuração). |
| ReturnTransition |
Retorna a Transição que será usada para mover Exibições para fora da cena quando o Fragmento estiver se preparando para ser removido, oculto ou desanexado devido ao estouro da pilha traseira. |
| SharedElementEnterTransition |
Retorna a Transição que será usada para elementos compartilhados transferidos para a Cena do conteúdo. |
| SharedElementReturnTransition |
Retorne a Transição que será usada para elementos compartilhados transferidos novamente durante um pop da pilha traseira. |
| Tag |
Obtenha o nome da marca do fragmento, se especificado. |
| TargetFragment |
Retornar o conjunto de fragmentos de destino por setTargetFragment(Fragment, int). |
| TargetRequestCode |
Retornar o conjunto de códigos de solicitação de destino por setTargetFragment(Fragment, int). |
| ThresholdClass |
Fornece infraestrutura de associação JNI para Android.App.Fragment. |
| ThresholdType |
Fornece infraestrutura de associação JNI para Android.App.Fragment. |
| UserVisibleHint |
Consulte também: |
| View |
Obtenha o modo de exibição raiz do layout do fragmento (aquele retornado por onCreateView(LayoutInflater, ViewGroup, Bundle)), se fornecido. |
Métodos
| Nome | Description |
|---|---|
| Clone() |
Cria e retorna uma cópia desse objeto. (Herdado de Object) |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| 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() |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| Dump(String, FileDescriptor, PrintWriter, String[]) |
Imprima o estado dos Fragmentos no fluxo fornecido. |
| Equals(Object) |
Obsoleto.
Subclasses não podem substituir equals(). |
| Equals(Object) |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| GetHashCode() |
Obsoleto.
As subclasses não podem substituir hashCode(). |
| GetString(Int32, Object[]) |
Retornar uma cadeia de caracteres formatada localizada da tabela de cadeia de caracteres padrão do pacote do aplicativo, substituindo os argumentos de formato conforme definido em Formatter e String.format(String, Object). |
| GetString(Int32) |
Retornar uma cadeia de caracteres localizada da tabela de cadeia de caracteres padrão do pacote do aplicativo. |
| GetText(Int32) |
Retorne um CharSequence localizado e com estilo da tabela de cadeia de caracteres padrão do pacote do aplicativo. |
| GetTextFormatted(Int32) |
Retorne um CharSequence localizado e com estilo da tabela de cadeia de caracteres padrão do pacote do aplicativo. |
| Instantiate(Context, String, Bundle) |
Crie uma nova instância de um Fragmento com o nome de classe fornecido. |
| Instantiate(Context, String) |
Como instanciar(Contexto, Cadeia de Caracteres, Pacote), mas com um pacote de argumento nulo. |
| JavaFinalize() |
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) |
| 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) |
| OnActivityCreated(Bundle) |
Chamado quando a atividade do fragmento foi criada e a hierarquia de exibição desse fragmento instanciada. |
| OnActivityResult(Int32, Result, Intent) |
Receba o resultado de uma chamada anterior para startActivityForResult(Intent,int). |
| OnAttach(Activity) |
Esse método foi preterido no nível 23 da API. |
| OnAttach(Context) |
Chamado quando um fragmento é anexado pela primeira vez ao seu contexto. |
| OnAttachFragment(Fragment) |
Chamado quando um fragmento é anexado como um filho deste fragmento. |
| OnConfigurationChanged(Configuration) |
Chamado pelo sistema quando a configuração do dispositivo é alterada enquanto o componente está em execução. |
| OnContextItemSelected(IMenuItem) |
Esse gancho é chamado sempre que um item em um menu de contexto é selecionado. |
| OnCreate(Bundle) |
Chamado para fazer a criação inicial de um fragmento. |
| OnCreateAnimator(FragmentTransit, Boolean, Int32) |
Chamado quando um fragmento carrega uma animação. |
| OnCreateContextMenu(IContextMenu, View, IContextMenuContextMenuInfo) |
Chamado quando um menu de contexto para a exibição está prestes a ser mostrado. |
| OnCreateOptionsMenu(IMenu, MenuInflater) |
Inicialize o conteúdo do menu de opções padrão da Atividade. |
| OnCreateView(LayoutInflater, ViewGroup, Bundle) |
Chamado para que o fragmento instancie sua exibição de interface do usuário. |
| OnDestroy() |
Chamado quando o fragmento não está mais em uso. |
| OnDestroyOptionsMenu() |
Chamado quando os itens de menu de opção desse fragmento não estão mais sendo incluídos no menu de opções gerais. |
| OnDestroyView() |
Chamado quando a exibição criada anteriormente por onCreateView(LayoutInflater, ViewGroup, Bundle) foi desanexada do fragmento. |
| OnDetach() |
Chamado quando o fragmento não está mais anexado à atividade. |
| OnGetLayoutInflater(Bundle) |
Retorna o LayoutInflater usado para inflar exibições deste fragmento. |
| OnHiddenChanged(Boolean) |
Chamado quando o estado oculto (conforme retornado por isHidden() do fragmento foi alterado. |
| OnInflate(Activity, IAttributeSet, Bundle) |
Esse método foi preterido no nível 23 da API. |
| OnInflate(Context, IAttributeSet, Bundle) |
Chamado quando um fragmento está sendo criado como parte de uma inflação de layout de exibição, normalmente de definir o modo de exibição de conteúdo de uma atividade. |
| OnInflate(IAttributeSet, Bundle) |
Obsoleto.
Esse método foi preterido no nível 15 da API. |
| 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. |
| OnMultiWindowModeChanged(Boolean, Configuration) |
Chamado quando a atividade do Fragmento muda do modo de tela inteira para o modo de várias janelas e visa-versa. |
| OnMultiWindowModeChanged(Boolean) |
Esse método foi preterido no nível 26 da API. |
| 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). |
| OnPause() |
Chamado quando o Fragmento não é mais retomado. |
| OnPictureInPictureModeChanged(Boolean, Configuration) |
Chamado pelo sistema quando a atividade muda de e para o modo de imagem na imagem. |
| OnPictureInPictureModeChanged(Boolean) |
Esse método foi preterido no nível 26 da API. |
| OnPrepareOptionsMenu(IMenu) |
Prepare o menu de opções padrão da Tela a ser exibido. |
| OnRequestPermissionsResult(Int32, String[], Permission[]) |
Retorno de chamada para o resultado da solicitação de permissões. |
| OnResume() |
Chamado quando o fragmento está visível para o usuário e em execução ativamente. |
| OnSaveInstanceState(Bundle) |
Chamado para pedir ao fragmento para salvar seu estado dinâmico atual, para que ele possa ser reconstruído posteriormente em uma nova instância de seu processo é reiniciado. |
| OnStart() |
Chamado quando o Fragmento está visível para o usuário. |
| OnStop() |
Chamado quando o fragmento não é mais iniciado. |
| OnTrimMemory(TrimMemory) |
Chamado quando o sistema operacional determinou que é um bom momento para um processo cortar a memória desnecessária de seu processo. |
| OnViewCreated(View, Bundle) |
Chamado imediatamente após onCreateView(LayoutInflater, ViewGroup,Bundle) ter retornado, mas antes que qualquer estado salvo tenha sido restaurado no modo de exibição. |
| OnViewStateRestored(Bundle) |
Chamado quando todo o estado salvo foi restaurado na hierarquia de exibição do fragmento. |
| PostponeEnterTransition() |
Adie a transição de fragmento de entrada até que startPostponedEnterTransition() ou FragmentManager.executePendingTransactions() tenha sido chamado. |
| 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). |
| RequestPermissions(String[], Int32) |
Solicita permissões a serem concedidas a este aplicativo. |
| SetEnterSharedElementCallback(SharedElementCallback) |
Quando transições personalizadas são usadas com Fragmentos, o retorno de chamada de transição de entrada é chamado quando esse fragmento é anexado ou desanexado quando não estoura a pilha traseira. |
| SetExitSharedElementCallback(SharedElementCallback) |
Quando transições personalizadas são usadas com Fragmentos, o retorno de chamada de transição de saída é chamado quando esse fragmento é anexado ou desanexado ao estourar a pilha de trás. |
| SetHandle(IntPtr, JniHandleOwnership) |
Define a propriedade Handle (Herdado de Object) |
| SetHasOptionsMenu(Boolean) |
Informe que esse fragmento gostaria de participar na população do menu de opções recebendo uma chamada para onCreateOptionsMenu(Menu, MenuInflater) e métodos relacionados. |
| SetInitialSavedState(Fragment+SavedState) |
Defina o estado salvo inicial do qual esse Fragmento deve ser restaurado quando for construído pela primeira vez, conforme retornado por FragmentManager.saveFragmentInstanceState. |
| SetMenuVisibility(Boolean) |
Defina uma dica para saber se o menu desse fragmento deve estar visível. |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| SetTargetFragment(Fragment, Int32) |
Destino opcional para este fragmento. |
| ShouldShowRequestPermissionRationale(String) |
Obtém se você deve mostrar a interface do usuário com lógica antes de solicitar uma permissão. |
| StartActivity(Intent, Bundle) |
Chamar Activity.startActivity(Intent,Bundle) da atividade que contém o fragmento. |
| StartActivity(Intent) |
Chamar Activity.startActivity(Intent) da atividade que contém o fragmento. |
| StartActivityForResult(Intent, Int32, Bundle) |
Chamar Activity.startActivityForResult(Intent, int,Bundle) da atividade que contém o fragmento. |
| StartActivityForResult(Intent, Int32) |
Chamar Activity.startActivityForResult(Intent,int) da atividade que contém o fragmento. |
| StartIntentSenderForResult(IntentSender, Int32, Intent, ActivityFlags, ActivityFlags, Int32, Bundle) |
Call Activity.startIntentSenderForResult(IntentSender,int,Intent,int,int,int,Bundle) do fragmento que contém a Atividade. |
| StartPostponedEnterTransition() |
Inicie as transições adiadas depois que postponeEnterTransition() foi chamado. |
| 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) |
| 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) |
| 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() |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| IJavaPeerable.Finalized() |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| IJavaPeerable.JniObjectReferenceControlBlock |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Essa classe foi preterida no nível 28 da API. (Herdado de JavaObject) |
| IJavaPeerable.UnregisterFromRuntime() |
Essa classe foi preterida no nível 28 da API. |
Métodos de Extensão
| Nome | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtém o nome JNI do tipo da instância |
| JavaAs<TResult>(IJavaPeerable) |
Tente coagir a digitar |
| JavaCast<TResult>(IJavaObject) |
Executa uma conversão de tipo marcada por runtime do Android. |
| JavaCast<TResult>(IJavaObject) |
Essa classe foi preterida no nível 28 da API. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Tente coagir a digitar |