Fragmentos do Android
Android Fragments são componentes modulares que representam uma parte de uma interface de usuário e foram introduzidos no Android 3.0.
Os fragmentos têm seu próprio ciclo de vida, que está intimamente ligado ao ciclo de vida da atividade que os contém e podem ser adicionados ou removidos em tempo de execução, permitindo um design de interface do usuário dinâmico e flexível.
Um Fragment é definido em uma classe Java que estende a classe Fragment e possui seus próprios métodos para controlar seu comportamento e aparência.
Para usar um Fragment em uma Activity, a Activity precisa incluir um FragmentManager, que é responsável por gerenciar o ciclo de vida do Fragment e sua colocação no layout da Activity.
Os fragmentos podem se comunicar uns com os outros e com a atividade usando interfaces e métodos de retorno de chamada, permitindo que eles passem dados ou eventos para outros componentes.
Ciclo de vida do fragmento do Android
O ciclo de vida de um fragmento Android está intimamente ligado ao ciclo de vida da Activity que o contém.
Embora os fragmentos tenham seu próprio conjunto de eventos de ciclo de vida, sua execução é influenciada pelo ciclo de vida da atividade. O seguinte é o ciclo de vida do fragmento:
| Métodos | Visão geral |
| onAttach() | O anexo inicial do fragmento à atividade aciona esse método. Aqui, o fragmento pode obter uma referência à atividade que o contém. |
| onCreate() | Quando o fragmento é criado pela primeira vez, esse método é chamado. É aqui que o Fragment pode realizar qualquer inicialização que precise. |
| onCreateView() | Este método é chamado quando é hora de criar a interface de usuário do Fragment. O fragmento infla seu layout e retorna a exibição raiz para o fragmento. |
| onViewCreated() | Após a criação da View do Fragmento, este método é chamado. É aqui que o Fragment pode realizar configurações adicionais em sua View. |
| onStart() | Este método é chamado quando o Fragment se torna visível para o usuário, mas ainda não é interativo. |
| Resumindo() | Quando o Fragment está pronto para receber a entrada do usuário, esse método é chamado. O fragmento é interativo e pode responder à entrada do usuário. |
| onPause() | Quando o Fragment não está mais em primeiro plano e não pode mais responder à entrada do usuário, esse método é chamado. O fragmento salva todos os dados que precisam ser persistidos neste ponto. |
| onStop() | Este método é chamado quando o Fragment não está mais visível para o usuário e não é mais interativo. |
| onDestroyView() | Este método é chamado quando a View do Fragmento está sendo destruída. O Fragment limpa todos os recursos que foram alocados em onCreateView(). |
| onDestroy() | Quando o Fragmento está sendo destruído, este método é chamado. É aqui que o Fragmento realiza qualquer limpeza final antes de ser destruído. |
| onDetach() | Este método é chamado quando o Fragment está sendo separado da Activity. Aqui, o fragmento pode liberar quaisquer recursos vinculados à atividade. |
Criar um fragmento
Para criar um Fragment, precisamos estender a classe Fragment e sobrescrever alguns de seus métodos.
Aqui está um exemplo de um fragmento simples:
public class MyFragment extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_my, container, false);
}
}
Este exemplo mostra como estender a classe Fragment para criar um novo Fragment.
Para aumentar o layout do Fragment, o método onCreateView() é substituído.
O método inflater.inflate() infla o layout e retorna um objeto View, que é então retornado pelo método onCreateView() .
Podemos adicionar um Fragment a uma Activity usando um FragmentManager. Aqui está um exemplo de como adicionar um fragmento a uma atividade:
FragmentManager fragmentManager = getFragmentManager(); FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction(); MyFragment myFragment = new MyFragment(); fragmentTransaction.add(R.id.fragment_container, myFragment); fragmentTransaction.commit();
Um FragmentManager pode ser recuperado chamando getFragmentManager() . Em seguida, criamos um novo FragmentTransaction e adicionamos uma instância do nosso Fragment a ele. Para adicionar o Fragment à Activity, nós confirmamos o FragmentTransaction.
Para exibir um Fragment em uma Activity, precisamos criar um arquivo de layout contendo um container para o Fragment.
Um arquivo de layout para uma Activity contendo um container Fragment se parece com isto:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity" > <FrameLayout android:id="@+id/fragment_container" android:layout_width="match_parent" android:layout_height="match_parent" /> </RelativeLayout>
No exemplo acima, criamos um RelativeLayout que contém um FrameLayout com um id de fragment_container.
É aqui que o fragmento será exibido.
Tipos de Fragmentos
No Android, existem dois tipos de fragmentos:
| tipos | Visão geral |
| Fragmentos Estáticos | Esses são fragmentos definidos no arquivo XML de layout de uma atividade e fazem parte da hierarquia de layout da atividade . Uma vez definidos, eles são estáticos e não podem ser removidos ou substituídos em tempo de execução. |
| Fragmentos Dinâmicos | São fragmentos que podem ser adicionados, removidos ou substituídos em tempo de execução, proporcionando mais flexibilidade à UI. Os fragmentos dinâmicos são adicionados a uma atividade programaticamente e são gerenciados pelo FragmentManager. |
Os fragmentos estáticos fornecem uma abordagem mais estruturada para a construção da interface do usuário, enquanto os fragmentos dinâmicos fornecem mais flexibilidade e podem se adaptar às alterações na interface do usuário em tempo de execução.
Como desenvolvedor, você deve escolher o tipo apropriado de fragmento com base nos requisitos de seu aplicativo .
Vantagens de usar Fragmentos
| Vantagens | Visão geral |
| Reutilização | Os fragmentos podem ser reaproveitados em diversas atividades, facilitando o desenvolvimento e a manutenção de uma aplicação. |
| Flexibilidade | Os fragmentos podem ser combinados com outros fragmentos para criar uma interface de usuário flexível e escalável. |
| Modularidade | Os fragmentos facilitam a organização do código e separam a funcionalidade em módulos independentes. |
