Prefácio
Depois de aprender Java e Android por quase um ano, os resultados do período devem ser preencher independentemente um cliente Android e garantir a estabilidade de sua versão da linha principal. Durante o período, encontrei muito poço e também aprendi muito conhecimento do Android com meu irmão. Mas as pessoas sempre têm que abraçar as mudanças e não se sentirem muito confortáveis. Aqui resumimos o maior número de fragmentos usados nos itens anteriores.
Introdução ao fragmento
O fragmento pode ser entendido como um comportamento ou parte da interface do usuário na atividade e deve ser aninhado na atividade. Mas um fragmento possui seu próprio arquivo de layout XML independente e é uma boa embalagem.
Criar fragmento
Crie um fragmento e crie uma atividade.
Os arquivos de layout XML são os mesmos que outros arquivos de layout.
<? Match_pareat "Android: Orientation =" Vertical "> <TextView Android: id ="@+id /textView "Android: layout_width =" wrap_content "Android: la yout_height =" wrap_content " > <Button Android: id = "@+id /button" Android: layout_width = "wrap_content" Android: layout_height = "wrap_content" Android: text = "@String /Button" /> </linearlayout>
No código Java, em geral, os seguintes métodos do ciclo de vida podem ser implementados conforme necessário: Fragmento:
1. OnAttach (): Quando o fragmento depende da atividade, você pode obter o identificador de atividade nesse método para alcançar a comunicação entre o fragmento e a atividade.
2. OnCreate (): Inicialize o quadro.
3. OnCreateView (): O sistema chama esse método ao desenhar a interface do usuário pela primeira vez para o fragmento.
4. OnactivityCreated (): Depois de ser executado pela função OnCreate da atividade do host, você pode executar a própria instância do widget do Fragment e o processamento da lógica de negócios nesse método.
5. OnDestoryView (): Ligue quando o quadro começar a ser destruído.
6. OnStart (): Chame quando o fragmento pode ser visível.
Existem também muitas outras funções de retorno de chamada que são usadas para manipular o ciclo de vida do fragmento.
Ciclo de vida do fragmento
Cada fragmento tem seu próprio conjunto de métodos de retorno de chamada do ciclo de vida e lida com seus próprios eventos de entrada do usuário. O ciclo de vida correspondente é mostrado na figura abaixo:
Adicionar fragmento à atividade
Primeiro de tudo, você precisa garantir que a acitividade suporta fragmento; portanto, a atividade geralmente precisa herdar da Fragmentativity. Geralmente, existem dois métodos para adicionar fragmento à atividade: estático e dinâmico.
O método estático adiciona fragmento diretamente ao arquivo de atividades XML, como mostrado abaixo:
<? Match_pareArnt "Android: Baselinealigned =" False "Android: Orientation =" Horizontal "> <Fragmento Android: id ="@+id/primeiro "Android: name =" com. Layout_Height = "Match_Parent" Android: layout_weight = "1" /> <fragmento Android: id = "@+id /segundo" Android: name = "com.example.se condfragment" Android: Layout_width = "0dp" Android: Layout_Height = "Match_Parent" Android: layout_weight = "1" /> < /linearlayout>
Quando o atributo Android: Nome em <Fragment> especifica a classe de fragmentos instanciados no layout, quando o layout da atividade é criado, ele instanciou cada quadro no arquivo de layout e os chama para ligar para obter cada um para obter cada um . O sistema insere diretamente a visualização retornada pelo local do elemento <ragment>
Nota: Cada fragmento requer uma identificação exclusiva. Existem três maneiras de fornecer IDs para fragmento: existem três maneiras:
Método dinâmico
Use FragmentTrans escation. Você pode usar a API de FragmentTransscation para operar o fragmento de atividade (como adicionar, remover ou substituir o fragmento). O código de referência é o seguinte:
FragmentManager FragmentManager = GetFragmentManager () FragmentTransact FragmentTaction = FragmentManager.BegIntraction ();
O primeiro parâmetro da função Add () é o grupo de vista do fragmento, que é especificado pelo ID do recurso (ID do recurso). Uma vez alterado por meio de fragmentação, deve entrar em vigor com as alterações visuais commit ().
Fragmentos de comunicação
Os fragmentos não devem ser comunicados diretamente e a interação entre eles deve ser realizada através da atividade do host. Existem três maneiras de interagir com fragmento e acitividade:
1. A atividade cria um fragmento com parâmetros.
2. A atividade mantém o identificador de objeto do fragmento, que pode ser chamado diretamente de método público do fragmento através da alça.
3. O fragmento pode obter a alça do ouvinte definida na função Onattach.
Crie o quadro com parâmetros
Em alguns casos específicos, o fragmento pode exigir parâmetros específicos para inicializar. Como o fragmento deve ter apenas um construtor de ginseng, você pode considerar o uso do método estático NewInstance para criar um fragmento com parâmetros. O código de exemplo é o seguinte:
Importar Android.OS.Bundle; ;
Você pode simplesmente carregar um parâmetro com parâmetros na atividade:
FragmentTransact Ft = GetSupportFragmentManager ().
O método de chamar fragmento
Como a atividade pode obter a alça de fragmento incorporada, esse método pode ser chamado diretamente através da alça do fragmento.
Public class TestFragment estende o fragmento {public void Dosomething (String param) {// Faça algo em fragmento}}} Na atividade, você pode chamar esse método diretamente através do identificador de objeto do fragmento:
Classe pública MainAction estende o FragmentActivity {@Override public void OnCreate (pacote Savedancestate) {Super.OnCreate (Savedincestate); Ouvinte de fragmento
Se o fragmento precisa compartilhar eventos com atividade, esse método precisará ser usado. O fragmento define uma interface e essa interface é implementada por atividade. A atividade da interface será alcançada no método onattach ().
O código de interface definido em fragmento é o seguinte:
Importar Android.support.v4.app.fragment; Use para tornar a interface pública de comunicação oniTemSelectListener {public void onrSesiSitemSelect (string link);} // Armazene o ouvinte (atividade) que terá eventos disparados assim que o fragmento estiver anexado @Override Public Void Onattach (atividade da atividade) {Super.onattach (Atividade ); Ouvinte.onrSSItemSelect ("algum link");}}Implementar esta interface na atividade:
Importar Android.support.v4.app.fragmentActivity; detalhefragment);} // Agora podemos definir a ação no ativá -lo quando o evento de fragmento arquivos @Override public void onrSesiSiteMSelect (link string) {if (fragment! = null && fragment.isinlayout ()) {fragment.settext (link );}}}