5/25/2018 Android - Programao - Viso Geral.pdf
1/267
AndersonDuarte
deAmorim
2
011
ANDROID,umavis
ogeral
5/25/2018 Android - Programao - Viso Geral.pdf
2/267
ANDROID, uma viso geralAnderson Duarte de Amorim 2
ContedoIntroduo ....................................................................................................................... 10Atividades ....................................................................................................................... 11
Criar uma atividade .................................................................................................... 11Implementando uma interface de usurio ................................................................... 12Declarando a atividade no manifesto.......................................................................... 13O uso de filtros inteno ............................................................................................. 13Iniciar uma atividade .................................................................................................. 14Iniciar uma atividade para um resultado..................................................................... 15Encerrar uma atividade ............................................................................................... 16Gerenciando o ciclo de atividade................................................................................ 16Aplicar o ciclo de vida callbacks ................................................................................ 17Salvando estado de atividade ...................................................................................... 23Manipulao de alteraes na configurao ............................................................... 25Coordenar as atividades .............................................................................................. 26
Fragmentos ..................................................................................................................... 27Filosofia de design ...................................................................................................... 27Criando um fragmento ................................................................................................ 29
DialogFragment ...................................................................................................... 30ListFragment ........................................................................................................... 31PreferenceFragment ................................................................................................ 31Adicionando uma interface de usurio ................................................................... 31Criando um layout .................................................................................................. 32Adicionando um fragmento de uma atividade ........................................................ 32Adicionando um fragmento sem uma interface de usurio (UI) ............................ 34Gerenciando fragmentos ......................................................................................... 35Executando transaes com fragmento .................................................................. 35
5/25/2018 Android - Programao - Viso Geral.pdf
3/267
ANDROID, uma viso geralAnderson Duarte de Amorim 3
Comunicando-se com a atividade ........................................................................... 37Criar callbacks evento para a atividade .................................................................. 38Adicionando itens barra de ao .......................................................................... 39Manuseio do ciclo de vida do fragmento................................................................ 40Coordenao com o ciclo de vida de atividade ...................................................... 41
Loaders ........................................................................................................................... 43Resumo API Loader ................................................................................................... 43Usando carregadores em um aplicativo ...................................................................... 44
Iniciando um Loader ............................................................................................... 45Reiniciando o Loader.............................................................................................. 46Usando callbacks do LoaderManager..................................................................... 47
Exemplo ...................................................................................................................... 50Tarefas e pilha de execuo ............................................................................................ 53
Salvando estado de atividade ...................................................................................... 56Gerenciando tarefas .................................................................................................... 57Definio de modos de lanamento ............................................................................ 58Usando o arquivo de manifesto .................................................................................. 59Usando as opes de intenes ................................................................................... 61Manipulao de afinidades ......................................................................................... 62Limpando a pilha de volta .......................................................................................... 64Iniciando uma tarefa ................................................................................................... 65
Servios .......................................................................................................................... 66O bsico ...................................................................................................................... 67
Voc deve utilizar um servio ou um thread? ........................................................ 67Declarando um servio no manifesto ..................................................................... 69
Criando um servio iniciado ....................................................................................... 70Segmentao Android 1.6 ou inferior..................................................................... 70
5/25/2018 Android - Programao - Viso Geral.pdf
4/267
ANDROID, uma viso geralAnderson Duarte de Amorim 4
Estendendo a classe IntentService .......................................................................... 71Estendendo a classe de servio ............................................................................... 73Iniciando um servio .............................................................................................. 77Parando um servio ................................................................................................ 77
Criando um servio vinculado .................................................................................... 78Enviando notificaes para o usurio ......................................................................... 79Executando um servio em primeiro plano ................................................................ 79Gerenciando ciclo de vida de um servio ................................................................... 80
Aplicando o ciclo de vida dos callbacks ................................................................. 81Servios vinculados ........................................................................................................ 84
O bsico ...................................................................................................................... 84Vinculao a um servio iniciado ........................................................................... 84
Criando um servio ligado .......................................................................................... 85Estendendo a classe Binder .................................................................................... 87Usando um Messenger ........................................................................................... 90
Vinculao a um servio............................................................................................. 93Notas adicionais ...................................................................................................... 95
Gerenciando o ciclo de vida de um servio de associao ......................................... 96Processos e threads ......................................................................................................... 98
Processos .................................................................................................................... 98Ciclo de vida do processo ....................................................................................... 99
Thread ....................................................................................................................... 102Threads funcionais ................................................................................................ 103Usando AsyncTask ............................................................................................... 104Mtodos de Thread-safe ....................................................................................... 106
Comunicao entre processos ................................................................................... 106Interface de usurio ...................................................................................................... 108
5/25/2018 Android - Programao - Viso Geral.pdf
5/267
ANDROID, uma viso geralAnderson Duarte de Amorim 5
Hierarquia de view.................................................................................................... 108Como o Android desenha views ........................................................................... 109
Layout ....................................................................................................................... 111Widgets ..................................................................................................................... 112Eventos UI ................................................................................................................ 114Menus ....................................................................................................................... 114Tpicos Avanados .................................................................................................. 115
Adaptadores .......................................................................................................... 115Estilos e Temas ..................................................................................................... 116
Declarando Layout ....................................................................................................... 117Escreve o XML ......................................................................................................... 118Carregar os recursos XML ....................................................................................... 119Atributos ................................................................................................................... 119
ID .......................................................................................................................... 119Parmetros de layout ............................................................................................ 120
Posio de Layout ..................................................................................................... 122Tamanho, padding e margin ..................................................................................... 122
Criando Menus ............................................................................................................. 124Menu de Opes ................................................................................................... 124Menu de Contexto ................................................................................................ 124Submenu ............................................................................................................... 124
Criando um recurso de menu .................................................................................... 124Inflar um recurso de menu ........................................................................................ 126Criando um Menu de Opes ................................................................................... 126
Respondendo ao do usurio............................................................................ 127Alterando os itens de menu em tempo de execuo ............................................. 129
Criando um Menu de Contexto ................................................................................ 129
5/25/2018 Android - Programao - Viso Geral.pdf
6/267
ANDROID, uma viso geralAnderson Duarte de Amorim 6
Registre uma ListView ......................................................................................... 130Criando Submenus .................................................................................................... 132Outras funes do menu ........................................................................................... 132
Grupos de Menu ................................................................................................... 132Itens de menu verificados ..................................................................................... 133As teclas de atalho ................................................................................................ 135Adicionar intenes em menu dinamicamente ..................................................... 136Permitindo a sua atividade a ser adicionada para outros menus........................... 137
Usando a barra de ao ................................................................................................. 139Adicionando a barra de ao .................................................................................... 139
Removendo a barra de ao .................................................................................. 140Adicionando itens de ao ........................................................................................ 141
Usando o cone do aplicativo como um item de ao .......................................... 142Usando o cone do aplicativo para navegar "para cima" ...................................... 143
Adicionando uma exibio de ao .......................................................................... 144Adicionando abas ..................................................................................................... 146Adicionando de navegao drop-down .................................................................... 149
Exemplo de SpinnerAdapter e OnNavigationListener ......................................... 150Estilizando a barra de ao ....................................................................................... 152
Criando caixas de dilogo............................................................................................. 156Mostrando uma caixa de dilogo .............................................................................. 156Dispensar um dilogo ............................................................................................... 158
Usando demisso de receptores ............................................................................ 158Criando um AlertDialog ........................................................................................... 159
Adicionando botes .............................................................................................. 160Adicionando uma lista .......................................................................................... 161Adicionando caixas de seleo e botes de rdio ................................................. 161
5/25/2018 Android - Programao - Viso Geral.pdf
7/267
ANDROID, uma viso geralAnderson Duarte de Amorim 7
Criar um ProgressDialog .......................................................................................... 162Mostrando uma barra de progresso ...................................................................... 163
Criando uma caixa de dilogo personalizada ........................................................... 166Manipulando eventos de UI .......................................................................................... 169
Os ouvintes de eventos ............................................................................................. 169Manipuladores de eventos ........................................................................................ 172Modo de toque .......................................................................................................... 173Manipulao do foco ................................................................................................ 174
Notificar o usurio ........................................................................................................ 176Notificao brinde .................................................................................................... 176
Criando notificaes brinde .................................................................................. 177Notificao na barra de status ................................................................................... 179
Criao de notificaes da barra de status ............................................................ 180Notificao de dilogo .............................................................................................. 189
Aplicando estilos e temas ............................................................................................. 190Definio de estilos .................................................................................................. 190
Herana ................................................................................................................. 191Propriedades do estilo ........................................................................................... 192
Aplicando estilos e temas para a interface do usurio .............................................. 194Aplicar um estilo a uma view ............................................................................... 194Aplicar um tema a uma atividade ou aplicao .................................................... 195Selecione um tema baseado na verso de plataforma........................................... 196
Usando estilos e temas da plataforma ...................................................................... 196Recursos de aplicao ................................................................................................... 198Armazenamento de dados ............................................................................................. 201
Utilizando preferncias compartilhadas ................................................................... 201Preferncias do usurio ......................................................................................... 202
5/25/2018 Android - Programao - Viso Geral.pdf
8/267
ANDROID, uma viso geralAnderson Duarte de Amorim 8
Usando o armazenamento interno ............................................................................ 203Salvando os arquivos de cache ............................................................................. 204
Usando o armazenamento externo ............................................................................ 205Verificar a disponibilidade dos meios .................................................................. 205Acessando arquivos em armazenamento externo ................................................. 206Escondendo seus arquivos a partir da Media Scanner .......................................... 206Como salvar arquivos que devem ser compartilhados ......................................... 206Salvando os arquivos de cache ............................................................................. 207
Utilizando bancos de dados ...................................................................................... 208Banco de dados de depurao ............................................................................... 209
Usando uma conexo de rede ................................................................................... 209Artigos .......................................................................................................................... 210
Acessibilidade ........................................................................................................... 210Linguagens e recursos .......................................................................................... 210Linguagens e localidade ....................................................................................... 211Fazendo o dispositivo falar................................................................................ 211
Interface .................................................................................................................... 213Toque .................................................................................................................... 213
Gestos ....................................................................................................................... 216Mtodo de entrada de dados ................................................................................. 216Criando um mtodo de entrada de dados ............................................................. 223
Aes de desenhos .................................................................................................... 226Truques de layout: criando layouts eficientes .......................................................... 229Truques de layout: usando ViewStub ....................................................................... 234Truques de layout: mesclando layouts...................................................................... 237ListView, uma otimizao ........................................................................................ 244Live folders ............................................................................................................... 247
5/25/2018 Android - Programao - Viso Geral.pdf
9/267
ANDROID, uma viso geralAnderson Duarte de Amorim 9
Live Wallpapers ........................................................................................................ 252Usando webViews .................................................................................................... 254Funcionalidades ........................................................................................................ 255
Caixa de pesquisa ................................................................................................. 255Sistema ..................................................................................................................... 258
Alocao de memria ........................................................................................... 258Zipaling oferece uma otimizao fcil ................................................................. 260
Nota .............................................................................................................................. 263Fontes ........................................................................................................................... 263
Fontes das imagens ................................................................................................... 266Fontes dos artigos ..................................................................................................... 266
5/25/2018 Android - Programao - Viso Geral.pdf
10/267
ANDROID, uma viso geralAnderson Duarte de Amorim 10
Introduo
O Android um software open-source criado para os celulares e outros dispositivos. O
Android Open Source Project (AOSP), liderado pelo Google, est encarregado da
manuteno e desenvolvimento do Android. Muitos fabricantes de dispositivostrouxeram ao mercado de dispositivos rodando o Android, e eles so disponveis ao
redor do mundo.
O objetivo principal construir uma plataforma de software excelente para usurios de
todos os dias. Uma srie de empresas empenhou muitos engenheiros para atingir esse
objetivo, e o resultado uma produo total de produtos de consumo de qualidade, cuja
fonte aberta para customizao e portabilidade.
Voc pode encontrar mais informaes sobre o Android a partir destas pginas abaixo:
Filosofia de projeto e objetivos
Interagindo com o projeto
Compatibilidade com Android
Informaes sobre licenciamento
http://source.android.com/about/philosophy.htmlhttp://source.android.com/about/philosophy.htmlhttp://source.android.com/source/index.htmlhttp://source.android.com/source/index.htmlhttp://source.android.com/compatibility/index.htmlhttp://source.android.com/compatibility/index.htmlhttp://source.android.com/source/licenses.htmlhttp://source.android.com/source/licenses.htmlhttp://source.android.com/source/licenses.htmlhttp://source.android.com/compatibility/index.htmlhttp://source.android.com/source/index.htmlhttp://source.android.com/about/philosophy.html5/25/2018 Android - Programao - Viso Geral.pdf
11/267
ANDROID, uma viso geralAnderson Duarte de Amorim 11
Atividades
Uma Activity um componente do aplicativo que fornece uma tela com a qual os
usurios podem interagir, a fim de fazer algo, como discar o telefone, tirar uma foto,
enviar um e-mail, ou ver um mapa. Para cada atividade dada uma janela na qual sedesenha sua interface de usurio. A janela normalmente preenche a tela, mas pode ser
menor do que a tela e flutuar em cima de outras janelas.
Um aplicativo normalmente consiste de mltiplas atividades que so frouxamente
ligadas uns aos outros. Normalmente uma atividade em um aplicativo especificada
como a atividade principal", que apresentada ao usurio ao iniciar o aplicativo pela
primeira vez. Cada atividade pode comear outra atividade, a fim de executar aes
diferentes. Cada vez que comea uma nova atividade, a atividade anterior
interrompida, mas o sistema preserva a atividade em uma pilha (a "pilha de volta").
Quando uma nova atividade comea, empurrada para a pilha de volta e leva o foco do
usurio. A pilha de volta usa "last in, first out" como mecanismo de fila, ento, quando
o usurio est em uma atividade e pressione a tecla BACK, a atividade removida da
pilha (e destruda) e retoma a atividade anterior.
Quando uma atividade parada por causa de uma nova atividade, h uma notificao daalterao no estado atravs de mtodos de retorno da atividade do ciclo de vida.
Existem vrios mtodos de retorno que uma atividade possa receber, devido a uma
mudana em seu estado. Por exemplo, quando parado, sua atividade deve liberar todos
os objetos grandes, como conexes de rede ou banco de dados. Quando a atividade
recomea, voc pode readquirir os recursos necessrios e retomar as aes que foram
interrompidas. Estas transies de estado so todos parte do ciclo de atividade.
Criar uma atividade
Para criar uma atividade, voc deve criar uma subclasse da Activity (ou uma subclasse
existente do mesmo). Em sua subclasse, voc precisa implementar mtodos de callback
que chama o sistema quando ocorrem as transies de atividade entre diversos estados
do seu ciclo de vida, como quando a atividade est sendo criada, parou, recomeou, ou
foi destruda. Os dois mtodos de retorno mais importantes so:
onCreate(): Voc deve implementar este mtodo. O sistema chama isso ao criar a suaatividade. Dentro de sua aplicao, voc deve inicializar os componentes essenciais de
5/25/2018 Android - Programao - Viso Geral.pdf
12/267
ANDROID, uma viso geralAnderson Duarte de Amorim 12
sua atividade. Mais importante, este o lugar onde voc deve chamar setContentView()
para definir o layout para a atividade do usurio a interface.
onPause(): O sistema chama este mtodo como o primeiro indcio de que o usurio est
saindo de sua atividade (embora nem sempre signifique que a atividade est sendodestruda). Isso geralmente onde voc deve cometer quaisquer alteraes que devem
ser mantidas para alm da sesso atual do usurio (porque o usurio pode no voltar).
Existem vrios mtodos de retorno do ciclo de vida de outros que voc deve usar a fim
de proporcionar uma experincia de usurio mais fluida entre as atividades e manipular
interrupes inesperadas que causem a sua atividade a ser interrompida e at mesmo
destruda.
Implementando uma interface de usurio
A interface de usurio para uma determinada atividade assegurada por uma hierarquia
de pontos de vista - objetos derivam da classe View. Cada exibio controla um
determinado espao retangular dentro da janela da atividade e pode responder a
interao do usurio. Por exemplo, uma viso pode ser um boto que inicia uma ao
quando o usurio toc-la.
Android fornece um nmero de pontos de vista prontos que voc pode usar para criar e
organizar seu layout. "Widgets" so vistas que proporcionam um visual (interativo) de
elementos para a tela, como um boto, um campo texto, checkbox, ou apenas uma
imagem. "Esquemas" so pontos de vista derivados de ViewGroup que fornecem um
modelo de layout exclusivo para a estrutura derivada, como um layout linear, um layout
de grade, ou a disposio relativa. Voc pode criar uma subclasse da View e
ViewGroup (ou subclasses existentes) para criar seus prprios widgets e layouts eaplic-las ao seu layout atividade.
A maneira mais comum para definir um layout usando pontos de vista com um
arquivo XML salvo disposio em recursos do seu aplicativo. Dessa forma, voc pode
manter o design da sua interface de usurio separadamente do cdigo fonte que define o
comportamento da atividade. Voc pode definir o layout da interface do usurio para a
sua atividade com setContentView(), passando a identificao do recurso para o layout.
No entanto, voc tambm pode criar novas Views no seu cdigo de atividade e construir
5/25/2018 Android - Programao - Viso Geral.pdf
13/267
ANDROID, uma viso geralAnderson Duarte de Amorim 13
uma hierarquia de vista atravs da insero de novos Views em um ViewGroup, em
seguida, usar esse esquema, passando a raiz ViewGroup para setContentView().
Declarando a atividade no manifesto
Voc deve declarar a sua atividade no arquivo de manifesto para que ele seja acessvel
para o sistema. Para declarar sua atividade, abra o arquivo e adicione um
como um filho do . Por exemplo:
...
...
Existem vrios outros atributos que podem ser includos nesse elemento, para definir
propriedades, como o rtulo para a atividade, um cone para a atividade, ou um tema ao
estilo de interface do usurio da atividade.
O uso de filtros inteno
Um tambm pode especificar filtros diferentes, usando o , afim de declarar como outros componentes de aplicao podem ativ-lo.
Quando voc cria um novo aplicativo usando as ferramentas do Android SDK, a
atividade de topo que criada para voc automaticamente inclui a inteno de filtro que
declara a atividade e responde ao "principal" e deve ser colocado no "lanador" da
categoria. A inteno parece filtro como este:
O elemento especifica que este o "principal ponto de entrada" para o
aplicativo. O elemento especifica que esta atividade deve ser listada no
sistema lanador de aplicao.
5/25/2018 Android - Programao - Viso Geral.pdf
14/267
ANDROID, uma viso geralAnderson Duarte de Amorim 14
Se voc pretende que o seu aplicativo seja auto-suficiente e no permita que outras
aplicaes ativem as suas atividades, ento voc no precisa de nenhum outro filtro de
inteno. Apenas uma atividade deve ter a ao "principal" e "lanador" da categoria,
como no exemplo anterior. Atividades que voc no deseja disponibilizar para outros
aplicativos no devem ter a inteno de filtros e voc pode inici-los usando as
intenes explcitas.
No entanto, se voc quiser a sua atividade para responder s intenes implcitas que
so entregues a partir de outras aplicaes (e suas prprias), ento voc deve definir
filtros de inteno adicional para a sua atividade. Para cada tipo de inteno para o qual
pretende responder, voc deve incluir um que inclui um elemento
e, opcionalmente, um elemento e/ou um . Estes elementosespecificam o tipo de intenes para que sua atividade possa responder.
Iniciar uma atividade
Voc pode iniciar outra atividade, chamando startActivity(), passando-lhe uma Intent
que descreve a atividade que deseja iniciar. A inteno especifica qualquer atividade
exatamente o que deseja iniciar ou descreve o tipo de ao que deseja executar (e o
sistema seleciona a atividade adequada para voc, que pode mesmo ser de um aplicativodiferente). A inteno tambm pode transportar pequenas quantidades de dados a serem
utilizados pela atividade que iniciada.
Quando se trabalha dentro de sua prpria aplicao, muitas vezes voc precisa
simplesmente lanar uma atividade conhecida. Voc pode fazer isso criando uma
inteno que define explicitamente a atividade que deseja iniciar, usando o nome da
classe. Por exemplo, aqui est como uma atividade inicia outra atividade denominada
SignInActivity:
Intentintent =newIntent(this,SignInActivity.class);startActivity(intent);
No entanto, sua aplicao pode tambm querer executar alguma ao, como enviar um
e-mail, mensagem de texto, ou atualizao de status, usando dados de sua atividade.
Neste caso, sua aplicao no pode ter as suas prprias atividades para realizar tais
aes, para que voc possa aproveitar ao invs das atividades previstas por outras
aplicaes no dispositivo, que pode executar as aes para voc. Este o lugar onde as
5/25/2018 Android - Programao - Viso Geral.pdf
15/267
ANDROID, uma viso geralAnderson Duarte de Amorim 15
intenes so realmente valiosas, voc pode criar uma inteno que descreve uma ao
que deseja executar e o sistema inicia a atividade adequada a partir de outro aplicativo.
Se houver mltiplas atividades que podem manipular a inteno, ento o usurio pode
selecionar qual usar. Por exemplo, se voc quer permitir que o usurio envie uma
mensagem de e-mail, voc pode criar a seguinte inteno:
Intentintent =newIntent(Intent.ACTION_SEND);intent.putExtra(Intent.EXTRA_EMAIL,recipientArray);startActivity(intent);
OEXTRA_EMAILextra adicionado uma matriz de seqncia de endereos de e-mail
para onde o e-mail deve ser enviado. Quando um aplicativo de e-mail responde a esta
inteno, ele l a matriz de cadeia prevista na extrae as coloca no campo "Para" do
formulrio de composio de e-mail.
Iniciar uma atividade para um resultado
s vezes, voc pode querer receber um resultado da atividade que voc comear. Nesse
caso, iniciar a atividade, chamando startActivityForResult()(em vez de startActivity()).
Para ento receber o resultado da atividade subseqente, aplicar o onActivityResult(),
mtodo de retorno. Quando a atividade subseqente feita, ele retorna um resultado de
uma Intentpara o seu mtodo onActivityResult().
Por exemplo, talvez voc queira que o usurio escolha um de seus contatos, para que
sua atividade pode fazer algo com as informaes desse contato. Veja como voc pode
criar uma inteno e manipular o resultado:
privatevoidpickContact(){// Create an intent to "pick" a contact, as defined by the content provider URIIntentintent =newIntent(Intent.ACTION_PICK,Contacts.CONTENT_URI);
startActivityForResult(intent,PICK_CONTACT_REQUEST);}
@OverrideprotectedvoidonActivityResult(intrequestCode,intresultCode,Intentdata){
// If the request went well (OK) and the request was PICK_CONTACT_REQUESTif(resultCode ==Activity.RESULT_OK &&requestCode ==
PICK_CONTACT_REQUEST){// Perform a query to the contact's content provider for the contact's nameCursorcursor =getContentResolver().query(data.getData(),newString[]{Contacts.DISPLAY_NAME},null,null,null);if(cursor.moveToFirst()){// True if the cursor is not empty
intcolumnIndex =cursor.getColumnIndex(Contacts.DISPLAY_NAME);Stringname =cursor.getString(columnIndex);
http://developer.android.com/reference/android/content/Intent.html#EXTRA_EMAILhttp://developer.android.com/reference/android/content/Intent.html#EXTRA_EMAILhttp://developer.android.com/reference/android/content/Intent.html#EXTRA_EMAILhttp://developer.android.com/reference/android/content/Intent.html#EXTRA_EMAIL5/25/2018 Android - Programao - Viso Geral.pdf
16/267
ANDROID, uma viso geralAnderson Duarte de Amorim 16
// Do something with the selected contact's name...}
}}
Este exemplo mostra a lgica bsica que voc deve usar seu mtodo onActivityResult()
para lidar com um resultado de atividade. A primeira condio verifica se a solicitao
foi bem-sucedida, se for, ento o resultCode ser RESULT_OKe se a solicitao para
que este resultado est respondendo conhecido, neste caso, o requestCode coincide
com o segundo parmetro enviada com startActivityForResult(). De l, o cdigo
manipula o resultado de atividade, consultando os dados retornados de uma Intent.
O que acontece , um ContentResolver executa uma consulta contra um provedor de
contedo, que retorna um Cursor que permite que os dados consultados possam seremlidos.
Encerrar uma atividade
Voc pode encerrar uma atividade chamando seu mtodo finish(). Voc tambm pode
encerrar uma atividade separada que j comeou chamando finishActivity().
Nota:Na maioria dos casos, voc no deve terminar explicitamente uma atividade com
estes mtodos. Como discutido na seo seguinte sobre o ciclo de vida de atividade, o
sistema Android gerencia a vida de uma atividade para voc, ento voc no precisa
terminar a sua prpria atividade. Chamar esses mtodos pode afetar negativamente a
experincia do usurio e s deve ser usado quando voc realmente no quer que o
usurio retorne a esta instncia da atividade.
Gerenciando o ciclo de atividade
Gerenciar o ciclo de vida de suas atividades atravs da implementao de mtodos de
retorno essencial para desenvolver uma aplicao forte e flexvel. O ciclo de vida de
uma atividade est diretamente afetada pela sua associao com outras atividades, a sua
misso e voltar pilha.
Uma atividade pode existir em trs estados, essencialmente:
Retomado: A atividade est em primeiro plano da tela e tem o foco do usurio. (Esse
estado tambm por vezes referido como "run".)
5/25/2018 Android - Programao - Viso Geral.pdf
17/267
ANDROID, uma viso geralAnderson Duarte de Amorim 17
Em pausa: Outra atividade est em primeiro plano e tem foco, mas este ainda visvel.
Ou seja, outra atividade visvel na parte superior de um presente e que a atividade
parcialmente transparente ou no cobre a tela inteira. Uma atividade em pausa est
completamente viva (o objeto Activity mantido na memria, ele mantm todas as
informaes do estado e membro, e permanece preso ao gerenciador de janelas), mas
pode ser morta pelo sistema em situaes de pouca memria.
Parado: A atividade totalmente obscurecida por outra atividade (a atividade est
agora em "background"). A atividade parada tambm est ainda viva (o objeto Activity
mantido na memria, ele mantm todas as informaes do estado e membro, mas no
est ligado ao gerenciador de janelas). No entanto, j no visvel para o usurio e pode
ser morto pelo sistema quando a memria necessria em outro lugar.
Se uma atividade est em pausa ou parada, o sistema pode retir-la da memria, quer
por pedir para terminar (chamando seu finish()), ou simplesmente matar o processo.
Quando a atividade aberta novamente (depois de ter sido concludo ou morto), ela
deve ser criada por toda parte.
Aplicar o ciclo de vida callbacks
Quando uma atividade transita entrando e saindo dos diferentes estados descritos acima,
ele notificado atravs de vrios mtodos de retorno. Todos os mtodos de callback so
ganchos que voc pode substituir para fazer um trabalho adequado quando o estado da
sua atividade muda. A atividade seguinte inclui cada um dos mtodos de ciclo de vida
fundamentais:
publicclassExampleActivityextendsActivity{@Override
publicvoidonCreate(BundlesavedInstanceState){super.onCreate(savedInstanceState);// The activity is being created.
}@OverrideprotectedvoidonStart(){
super.onStart();// The activity is about to become visible.
}@OverrideprotectedvoidonResume(){
super.onResume();
// The activity has become visible (it is now "resumed").}
http://developer.android.com/reference/android/app/Activity.html#onCreate(android.os.Bundle)http://developer.android.com/reference/android/app/Activity.html#onCreate(android.os.Bundle)http://developer.android.com/reference/android/app/Activity.html#onStart()http://developer.android.com/reference/android/app/Activity.html#onStart()http://developer.android.com/reference/android/app/Activity.html#onStart()http://developer.android.com/reference/android/app/Activity.html#onResume()http://developer.android.com/reference/android/app/Activity.html#onResume()http://developer.android.com/reference/android/app/Activity.html#onResume()http://developer.android.com/reference/android/app/Activity.html#onResume()http://developer.android.com/reference/android/app/Activity.html#onStart()http://developer.android.com/reference/android/app/Activity.html#onCreate(android.os.Bundle)5/25/2018 Android - Programao - Viso Geral.pdf
18/267
ANDROID, uma viso geralAnderson Duarte de Amorim 18
@OverrideprotectedvoidonPause(){
super.onPause();// Another activity is taking focus (this activity is about to be "paused").
}@OverrideprotectedvoidonStop(){
super.onStop();// The activity is no longer visible (it is now "stopped")
}@OverrideprotectedvoidonDestroy(){
super.onDestroy();// The activity is about to be destroyed.
}}
Nota: A implementao destes mtodos do ciclo de vida deve sempre chamar aimplementao da superclasse antes de fazer qualquer trabalho, conforme mostrado
nos exemplos acima.
Juntos, esses mtodos definem o ciclo de vida de uma atividade. Ao implementar esses
mtodos, voc pode monitorar trs loops aninhados no ciclo de vida de atividade:
A vida inteirade uma atividade acontece entre a chamada para onCreate()e a
chamada para onDestroy(). Sua atividade deve executar a instalao do "Estado"
global (tal como a definio de layout) em onCreate(), e liberar todos os recursos
remanescentes em onDestroy(). Por exemplo, se a sua atividade tem um
segmento em execuo em segundo plano para transferir os dados da rede, ele
pode criar esse tpico em onCreate()e depois parar o segmento em onDestroy().
O tempo de vida visvel de uma atividade acontece entre a chamada para
onStart()e a chamada para onStop(). Durante este tempo, o usurio pode ver a
atividade na tela e interagir com ele. Por exemplo, onStop() chamado quandoinicia uma nova atividade e esta no mais visvel. Entre estes dois mtodos,
voc pode manter os recursos que so necessrios para mostrar a atividade para
o usurio. Por exemplo, voc pode registrar um BroadcastReceiver em onStart()
para monitorar as mudanas que impactam sua interface do usurio, e cancelar o
registro em onStop()quando o usurio no pode mais ver o que voc est sendo
exibido. O sistema pode chamar onStart()e onStop()vrias vezes durante toda a
vida til da atividade, como a atividade se alterna entre visvel e oculta para ousurio.
http://developer.android.com/reference/android/app/Activity.html#onPause()http://developer.android.com/reference/android/app/Activity.html#onPause()http://developer.android.com/reference/android/app/Activity.html#onPause()http://developer.android.com/reference/android/app/Activity.html#onStop()http://developer.android.com/reference/android/app/Activity.html#onStop()http://developer.android.com/reference/android/app/Activity.html#onStop()http://developer.android.com/reference/android/app/Activity.html#onDestroy()http://developer.android.com/reference/android/app/Activity.html#onDestroy()http://developer.android.com/reference/android/app/Activity.html#onDestroy()http://developer.android.com/reference/android/app/Activity.html#onDestroy()http://developer.android.com/reference/android/app/Activity.html#onStop()http://developer.android.com/reference/android/app/Activity.html#onPause()5/25/2018 Android - Programao - Viso Geral.pdf
19/267
ANDROID, uma viso geralAnderson Duarte de Amorim 19
O tempo de vida do primeiro planode uma atividade acontece entre a chamada
para onResume()e a chamada para onPause(). Durante este tempo, a atividade
est na frente de todas as outras atividades na tela e tem foco de entrada do
usurio. Uma atividade pode freqentemente transitar para dentro e fora do
plano, por exemplo, onPause() chamado quando o dispositivo vai dormir ou
quando uma caixa de dilogo aparece. O cdigo desses dois mtodos deve ser
bastante leve, para evitar transies lentas que fazem o usurio esperar.
A figura 1 ilustra esses laos e os caminhos de uma atividade que podem levar a esses
estados.
Figura 1.O ciclo de vida de atividade.
5/25/2018 Android - Programao - Viso Geral.pdf
20/267
ANDROID, uma viso geralAnderson Duarte de Amorim 20
Tabela 1.Um resumo do ciclo de vida do callback mtodos atividade.
Mtodo DescrioKillabledepois?
Seguinte
onCreate()
Chamado quando a atividade
criada pela primeira vez.Isto onde voc deve fazer
tudo do seu conjunto esttico
normal - criar pontos de vista,
vincular dados em listas, e
assim por diante. Sempre
seguido por onStart().
No onStart()
onRestart()
Chamado depois que a
atividade foi interrompida,
pouco antes de ele ser iniciado
novamente. Sempre seguido
por onStart()
No onStart()
onStart()
Chamado imediatamente antes
da atividade tornar-se visvel
para o usurio. Seguido por
onResume() se a atividade
vem para o primeiro plano, ou
onStop()se torna oculto.
No onResume()
onResume()
Chamado imediatamente antes
da atividade passar a interagir
com o usurio. Neste ponto, a
atividade est no topo da pilha
de atividade. Sempre seguidopor onPause().
No onPause()
5/25/2018 Android - Programao - Viso Geral.pdf
21/267
ANDROID, uma viso geralAnderson Duarte de Amorim 21
onPause()
Chamado quando o sistema
est prestes a comear a
retomar a outra atividade. Este
mtodo geralmente usado
para confirmar as alteraes
no salvas, dados persistentes,
animaes stop e outras coisas
que podem estar consumindo
CPU, e assim por diante. Ele
deve fazer tudo o que ele faz
muito rapidamente, porque a
prxima atividade no ser
retomada at que ele retorne.
Seguidas por onResume()se a
atividade retorna para a frente,
ou por onStop() se torna
invisvel para o usurio.
SimonResume() ou
onStop()
onStop()
Chamado quando a atividade
j no visvel para o usurio.
Isso pode acontecer porque
ele est sendo destrudo, ou
porque outra atividade (seja
um existente ou uma nova) foi
retomado e est cobrindo-o.
Seguidas por onRestart() se a
atividade est voltando para
interagir com o usurio, ou
por onDestroy() se essa
atividade est indo embora.
SimonRestart() ou
onDestroy()
5/25/2018 Android - Programao - Viso Geral.pdf
22/267
ANDROID, uma viso geralAnderson Duarte de Amorim 22
onDestroy()
Chamado antes que a
atividade destruda. Esta a
chamada final que a atividade
ir receber.Poderia ser
chamada, quer porque a
atividade est acabando
(algum chamado finish()
nela), ou porque o sistema
est destruindo essa instncia
da atividade para economizar
espao. Voc pode distinguir
entre estes dois cenrios com
o isFinishing().
Sim nada
A coluna chamada "killable depois?" indica se o sistema pode matar o processo que
acolhe a atividade a qualquer momento aps o mtodo retornar, sem executar outra
linha. Trs mtodos so marcados como "sim": (onPause() , onStop() , e onDestroy() ).
onPause() o primeiro dos trs, uma vez que a atividade criada, onPause() o ltimo
mtodo que garantido para ser chamado antes que o processo pode ser morto, se o
sistema deve recuperar a memria em caso de emergncia, ento onStop() e onDestroy()
no podem ser chamados. Portanto, voc deve usar onPause() para escrever dados
persistentes para armazenamento. No entanto, voc deve ser seletivo sobre quais
informaes devem ser mantidas durante onPause(), porque os procedimentos de
bloqueio neste mtodo bloqueiam a passagem para a prxima atividade e retardam a
experincia do usurio.
Mtodos que so marcados como "No" na coluna killable protegem o processo da
atividade de ser morto desde o momento em que so chamados. Assim, uma atividade
killable a partir do momento onPause() e retorna quando onResume() chamado. No
ser novamente killable at onPause() seja novamente chamado e retornado.
Nota:uma atividade que no tecnicamente "killable" por esta definio na tabela 1
ainda pode ser morta pelo sistema, mas isso vai acontecer apenas em circunstncias
extremas, quando no h outro recurso.
5/25/2018 Android - Programao - Viso Geral.pdf
23/267
ANDROID, uma viso geralAnderson Duarte de Amorim 23
Salvando estado de atividade
A introduo Gesto do Ciclo de Atividade menciona brevemente que, quando uma
atividade est em pausa ou parada, o estado da atividade mantido. Isto verdade
porque a Activityainda est retida na memria quando est em pausa ou parada, todas
as informaes sobre seus membros e estado atuais ainda esto vivos. Assim, qualquer
alterao que o usurio fez no mbito da atividade retida na memria, de modo que
quando a atividade retorna para o primeiro plano (quando ele "retoma"), essas
mudanas ainda esto l.
Figura 2.As duas formas em que para a atividade um usurio retorna ao foco com seu estado intacto,
quer a atividade interrompida, e retomada em seguida, o estado de atividade permanece intacta (
esquerda), ou a atividade destrudo, ento recriada e a atividade deve restaurar o estado da atividade
anterior (direita).
No entanto, quando o sistema destri uma atividade, a fim de recuperar a memria, a
Activity destruda, ento o sistema no pode simplesmente continuar com o seu estado
intacto. Em vez disso, o sistema deve recriar a Activityse o usurio navega de volta
para ele. No entanto, o usurio no sabe que o sistema destri e recria a atividade e,
assim, provavelmente espera que a atividade seja exatamente como era. Nessa situao,
5/25/2018 Android - Programao - Viso Geral.pdf
24/267
ANDROID, uma viso geralAnderson Duarte de Amorim 24
voc pode garantir que informaes importantes sobre o estado de atividade so
preservadas atravs da implementao de um mtodo de retorno adicional que permite
que voc salve as informaes sobre o estado de sua atividade e, em seguida, restaura
quando o sistema recria a atividade.
O mtodo de callback em que voc pode salvar informaes sobre o estado atual da sua
atividade onSaveInstanceState(). O sistema chama este mtodo antes de fazer a
atividade vulnervel a ser destruda e passa-lhe um objeto Bundle. O Bundle o lugar
onde voc pode armazenar informaes de estado sobre a atividade como pares valor-
nome, utilizando mtodos como putString(). Ento, se o sistema mata a atividade e o
usurio navega de volta para sua atividade, o sistema passa o Bundle para onCreate()
para que voc possa restaurar o estado de atividade que tenha sido guardado duranteonSaveInstanceState(). Se no h informaes do estado para restaurar, em seguida, o
Bundle que passou a onCreate()se torna nulo.
Nota:No h nenhuma garantia de que onSaveInstanceState()ser chamado antes de
sua atividade ser destruda, porque h casos em que no ser necessrio salvar o
estado (como quando o usurio deixa a sua atividade com a chave de volta, porque a
usurio explicitamente encerra as atividades). Se o mtodo for chamado, ele sempre
chamado antes de onStop() e, possivelmente, antes de onPause().
No entanto, mesmo se voc no faz nada e no implementar onSaveInstanceState(),
alguns estados de atividade so restaurados pela Activityde implementao padro da
classe de onSaveInstanceState(). Especificamente, a implementao padro chama
onSaveInstanceState() para cada View no layout, que permite fornecer informaes
sobre si que devem ser salvos. Quase todos os widgets no mbito Android implementam
este mtodo, de modo que qualquer mudana visvel para o interface do usurio so
automaticamente salvas e restauradas quando sua atividade recriada. Por exemplo, o
EditText salva qualquer texto digitado pelo usurio e o CheckBox widget salva se
marcado ou no. O nico trabalho exigido por voc fornecer uma identificao nica
(com o android:id) para cada elemento grfico que deseja salvar seu estado. Se um
elemento no tem um ID, ento ele no pode salvar seu estado.
Voc tambm pode parar explicitamente de salvar em seu layout seu estado, definindo o
android:saveEnabledpara "false" ou chamando o setSaveEnabled().Normalmente, voc
5/25/2018 Android - Programao - Viso Geral.pdf
25/267
ANDROID, uma viso geralAnderson Duarte de Amorim 25
no deve desativar isso, mas voc pode caso queira restaurar o estado da atividade de
interface diferente.
Embora a implementao padro de onSaveInstanceState()salva as informaes teis
sobre a atividade da sua interface, voc ainda pode precisar substitu-lo para guardarinformaes adicionais. Por exemplo, voc talvez precise salvar valores de um membro
que mudou na vida da atividade (que poderiam se correlacionar com os valores
restaurados na interface do usurio, mas os membros que detm esses valores UI no
so restaurados, por padro).
Como a implementao padro de onSaveInstanceState() ajuda a salvar o estado da
interface do usurio, se voc substituir o mtodo para salvar informaes de estado
adicionais, voc deve sempre chamar a implementao da superclasse de
onSaveInstanceState()antes de fazer qualquer trabalho.
Nota:Devido ao onSaveInstanceState()no ser garantido de ser chamado, voc deve
us-lo apenas para registrar o estado transiente da atividade (o estado da interface do
usurio), voc nunca deve us-lo para armazenar dados persistentes. Em vez disso,
voc deve usar onPause() para armazenar dados persistentes (como os dados que
devem ser salvos em um banco de dados) quando o usurio deixa a atividade.
Uma boa maneira de testar a capacidade do seu aplicativo para restaurar seu estado
simplesmente girar o dispositivo para fazer alteraes na orientao da tela. Quando da
mudana de orientao da tela, o sistema destri e recria a atividade a fim de aplicar
recursos alternativos que possam estar disponveis para a nova orientao. Por esta
razo, muito importante para sua atividade restaurar completamente o seu estado
quando ele recriado, pois os usurios regularmente giram a tela ao usar aplicaes.
Manipulao de alteraes na configurao
Algumas configuraes de dispositivo podem mudar durante a execuo (tais como a
orientao da tela, a disponibilidade de teclado e idioma). Quando essa mudana ocorre,
o Android reinicia a atividade em execuo (onDestroy() chamado, seguido
imediatamente por onCreate()). O comportamento reiniciar projetado para ajudar a sua
candidatura a se adaptar s novas configuraes automaticamente recarregando a sua
aplicao com recursos alternativos que voc forneceu. Se voc projeta sua atividade
5/25/2018 Android - Programao - Viso Geral.pdf
26/267
ANDROID, uma viso geralAnderson Duarte de Amorim 26
para lidar adequadamente com este evento, vai ser mais resistentes a eventos
inesperados no ciclo de atividade.
A melhor maneira de lidar com uma mudana de configurao, tais como uma mudana
na orientao da tela, simplesmente preservar o estado do seu aplicativo usandoonSaveInstanceState() e onRestoreInstanceState() (ou onCreate() ), como discutido na
seo anterior.
Coordenar as atividades
Quando uma atividade comea outra, ambas experimentam as transies do ciclo de
vida. A primeira atividade faz uma pausa e para (embora, no vai parar se ele ainda est
visvel ao fundo), enquanto a outra atividade criada. Caso esses dados compartilhamatividades salvas em disco ou em outro lugar, importante entender que a primeira
atividade no est completamente parada antes de a segunda ser criada. Pelo contrrio, o
processo de iniciar o segundo se sobrepe ao processo de parar o primeiro.
A ordem dos retornos do ciclo de vida bem definida, especialmente quando as duas
atividades esto no mesmo processo e est comeando um do outro. Aqui est a ordem
das operaes que ocorrem quando a atividade A comea atividade B:
1. O mtodo onPause() da atividade A executado.2. Os mtodos onCreate(), onStart(), e onResume() de B so executados em
seqncia. (Atividade B agora tem o foco do usurio.)
3. Ento, se uma atividade no mais visvel na tela, a sua onStop() executada.Esta seqncia previsvel de callbacks do ciclo de vida permite-lhe gerir a transio de
informaes de uma atividade para outra. Por exemplo, se voc deve escrever em um
banco de dados quando a primeira atividade pra para que esta atividade pode l-lo,
ento voc deve escrever para o banco de dados durante onPause() em vez de durante
onStop().
5/25/2018 Android - Programao - Viso Geral.pdf
27/267
ANDROID, uma viso geralAnderson Duarte de Amorim 27
Fragmentos
Um Fragmentrepresenta um comportamento ou uma parte da interface de usurio em
uma Activity. Voc pode combinar vrios fragmentos em uma nica atividade para
construir uma interface multi-painel e reutilizao de um fragmento de atividadesmltiplas. Voc pode pensar em um fragmento como uma seo modular de uma
atividade, que tem seu prprio ciclo de vida, recebe os seus prprios eventos de entrada,
e que voc pode adicionar ou remover, enquanto a atividade est em execuo.
Um fragmento deve sempre ser incorporado em uma atividade e o ciclo de vida do
fragmento diretamente afetado pelo ciclo de vida da atividade de acolhimento. Por
exemplo, quando a atividade interrompida, assim so todos os fragmentos nele, e
quando a atividade destruda, assim so todos os fragmentos. No entanto, enquanto
uma atividade est em execuo (que na retomadado ciclo de vida do estado), voc
pode manipular cada fragmento de forma independente, como adicionar ou remover.
Quando voc executa uma operao deste tipo de fragmento, voc tambm pode
adicion-la a uma pilha de volta que gerenciado pela atividade de cada pilha de volta
na entrada da atividade que um registro da transao de fragmento que ocorreu. A
volta da pilha permite que o usurio possa reverter uma transao (navegar para trs),
pressionando a tecla BACK.
Quando voc adiciona um fragmento como uma parte do seu layout, ele vive em um
ViewGroup dentro da view de hierarquia e define o seu prprio layout de pontos de
vista. Voc pode inserir um fragmento em seu layout declarando o fragmento na
atividade de distribuio de arquivos, como , ou a partir de seu cdigo de
aplicativo, adicionando-o a um j existente ViewGroup. No entanto, um fragmento no
obrigado a fazer parte do esquema de atividade, voc tambm pode utilizar um
fragmento como um trabalhador invisvel para a atividade.
Filosofia de design
Android apresenta fragmentos no Android 3.0 (API Level "Honeycomb"),
principalmente para apoiar projetos mais dinmicos e flexveis de interface do usurio
em telas grandes, como os Tablets. Como uma tela de tablet muito maior do que a de
um telefone, h mais espao para combinar e trocar os componentes de interface do
usurio. Fragmentos permitem tais projetos sem a necessidade de gerenciar mudanas
5/25/2018 Android - Programao - Viso Geral.pdf
28/267
ANDROID, uma viso geralAnderson Duarte de Amorim 28
complexas hierarquia vista. Ao dividir o layout de uma atividade em fragmentos, voc
se torna capaz de modificar a aparncia da atividade em tempo de execuo e preservar
essas mudanas em uma pilha de volta que gerenciada pela atividade.
Por exemplo, um aplicativo de notcias pode usar um fragmento para mostrar uma listade artigos esquerda e outro fragmento para mostrar um artigo direita, ento os
fragmentos aparecem em uma atividade, lado a lado, e cada fragmento tem seu prprio
conjunto do ciclo de vida, mtodos callback e lidam com seus prprios eventos de
entrada do usurio. Assim, em vez de usar uma atividade para selecionar um artigo e
outra atividade para ler o artigo, o usurio pode selecionar um artigo e ler tudo dentro da
mesma atividade, conforme ilustrado na figura 1.
Figura 1.Um exemplo de como dois mdulos de interface do usurio que normalmente so separados em
duas atividades podem ser combinados em uma atividade, utilizando fragmentos.
Um fragmento deve ser um componente modular e reutilizvel em sua aplicao. Ou
seja, porque o fragmento define o seu prprio layout e seu prprio comportamento,
usando seu prprio ciclo de vida callbacks, voc pode incluir um fragmento em
mltiplas atividades. Isto especialmente importante porque permite adaptar a sua
experincia de usurio para diferentes tamanhos de tela. Por exemplo, voc pode incluir
vrios fragmentos de uma atividade apenas quando o tamanho da tela suficientemente
grande, e, quando no , lanar atividades distintas que utilizam diferentes fragmentos.
Por exemplo, para continuar com o aplicativo de notcia, a aplicao pode inserir dois
fragmentos da atividade, quando rodando em uma grande tela extra (um tablet, por
exemplo). No entanto, em um tamanho de tela normal (um telefone, por exemplo), no
h lugar suficiente para os dois fragmentos, de modo a Atividade A inclui somente o
fragmento para a lista de artigos, e quando o usurio seleciona um artigo, ele comea a
5/25/2018 Android - Programao - Viso Geral.pdf
29/267
ANDROID, uma viso geralAnderson Duarte de Amorim 29
Atividade B, que inclui o fragmento para ler o artigo. Assim, a aplicao suporta os
padres de projeto sugerido na figura 1.
Criando um fragmento
Figura 2.O ciclo de vida de um fragmento (enquanto a sua atividade est em execuo).
5/25/2018 Android - Programao - Viso Geral.pdf
30/267
ANDROID, uma viso geralAnderson Duarte de Amorim 30
Para criar um fragmento, voc deve criar uma subclasse de Fragment(ou uma subclasse
existente do mesmo). O cdigo da classe Fragmentse parece muito com uma Activity.
Ele contm mtodos de retorno semelhante a uma atividade, como onCreate(), onStart(),
onPause(), e onStop(). Na verdade, se voc est convertendo uma aplicao Android
existentes para usar fragmentos, voc pode simplesmente mover o cdigo de mtodos
de retorno de sua atividade sobre os mtodos de retorno de seus respectivos fragmentos.
Normalmente, voc deve implementar pelo menos os mtodos do ciclo de vida a seguir:
onCreate():O sistema chama isso ao criar o fragmento. Dentro de sua aplicao, voc
deve inicializar os componentes essenciais do fragmento que pretende manter quando o
fragmento pausado ou parado, ento retomado.
onCreateView():O sistema chama isso quando est na hora de extrair o fragmento de
sua interface de usurio pela primeira vez. Para desenhar uma interface para o seu
fragmento, voc deve retornar um View a partir deste mtodo que a raiz do fragmento
do seu layout. Voc pode retornar nulo se o fragmento no fornece uma interface do
usurio.
onPause():O sistema chama este mtodo como o primeiro indcio de que o usurio est
saindo do fragmento (embora nem sempre significa que o fragmento est sendo
destrudo). Isso geralmente onde voc deve cometer quaisquer alteraes que devem
ser mantidas para alm da sesso atual do usurio (porque o usurio pode no voltar).
A maioria dos aplicativos devem implementar pelo menos estes trs mtodos para cada
fragmento, mas existem vrios mtodos de retorno que voc tambm deve usar para
lidar com diferentes fases do ciclo de vida do fragmento. Todos os mtodos de retorno
do ciclo de vida so discutidos mais adiante, na seo sobre o manuseio do Ciclo de
Vida do fragmento.
Existem tambm algumas subclasses que voc pode querer estender:
DialogFragment
Mostra uma janela flutuante. Usar essa classe para criar uma caixa de dilogo uma boa
alternativa para usar os mtodos auxiliares de dilogo na Activity, porque voc pode
incorporar um fragmento de dilogo para a volta da pilha de fragmentos gerido pelaatividade, permitindo que o usurio retorne a um fragmento rejeitado.
5/25/2018 Android - Programao - Viso Geral.pdf
31/267
ANDROID, uma viso geralAnderson Duarte de Amorim 31
ListFragment
Exibe uma lista de itens que so gerenciados por um adaptador (como um
SimpleCursorAdapter), semelhante ao ListActivity. Ele fornece diversos mtodos para
gerenciar uma lista, como o onListItemClick()de callback para manipular eventos declique.
PreferenceFragment
Exibe uma hierarquia de objetos Preference como uma lista, semelhante
PreferenceActivity. Isso til quando se cria um "settings" para sua aplicao.
Adicionando uma interface de usurio
Um fragmento normalmente usado como parte de uma atividade de interface de
usurio e contribui com a sua prpria disposio para a atividade.
Para fornecer um layout de um fragmento, voc deve implementar o onCreateView(),
que o sistema Android chama quando hora do fragmento ser desenhado no layout. A
implementao deste mtodo deve retornar um View que a raiz do fragmento do seu
layout.
Nota: Se o fragmento uma subclasse de ListFragment, a implementao padro
retorna um ListView de onCreateView(), ento voc no precisa implement-lo.
Para devolver um layout de onCreateView(), voc pode retir-lo a partir de um layout
de recursos definidos em XML e o desenvolve. Para ajud-lo a faz-lo, onCreateView()
fornece um LayoutInflater objeto.
Por exemplo, aqui est uma subclasse de Fragmentque carrega um layout a partir da
example_fragment.xml:
publicstaticclassExampleFragmentextendsFragment{@OverridepublicViewonCreateView(LayoutInflaterinflater,ViewGroupcontainer,
BundlesavedInstanceState){// Inflate the layout for this fragmentreturninflater.inflate(R.layout.example_fragment,container,false);
}}
5/25/2018 Android - Programao - Viso Geral.pdf
32/267
ANDROID, uma viso geralAnderson Duarte de Amorim 32
Criando um layout
No exemplo acima, R.layout.example_fragment uma referncia a um recurso chamado
layout example_fragment.xml salvo na aplicao dos recursos.
O parmetro passado para onCreateView() o pai ViewGroup (da atividade do layout),
em que o layout do fragmento ser inserido. O parmetro savedInstanceState um
Bundle que fornece dados sobre a instncia anterior do fragmento, se o fragmento est
sendo retomado.
O mtodo inflate() utiliza trs argumentos:
A identificao de recurso do layout que voc deseja inserir.
O ViewGroup ser o pai do layout j em utilizao. Passando o container
importante para que o sistema possa aplicar os parmetros de layout para o
modo de exibio raiz do layout inflado, especificado pela posio do pai em
que ele est indo.
Um booleano que indica se o layout desenvolvido dever ser anexado ao
ViewGroup (segundo parmetro) durante a chamada do procedimento inflate().
(Neste caso, isso falso, porque o sistema j est inserindo o layout inflado nocontainer de passagem verdade seria criar um grupo de vista redundantes no
layout final.)
Adicionando um fragmento de uma atividade
Normalmente, um fragmento contribui com uma parcela de UI para a atividade de
acolhimento, que incorporado como parte da hierarquia da viso da atividade de
conjunto. H duas maneiras com as quais voc pode adicionar um fragmento para olayout de atividade:
Declare o fragmento dentro atividade de layout do arquivo.
Neste caso, voc pode especificar propriedades de layout para o fragmento como se
fosse uma exibio. Por exemplo, aqui est o arquivo de layout para uma atividade
com dois fragmentos:
5/25/2018 Android - Programao - Viso Geral.pdf
33/267
ANDROID, uma viso geralAnderson Duarte de Amorim 33
O atributo android:namena especifica o Fragment para instanciar nolayout.
Quando o sistema cria esse layout, ele instancia cada fragmento especificado no
layout e chama o onCreateView()para cada um, para recuperar o layout de cada
fragmento. O sistema insere a View retornada pelo fragmento diretamente no
local do elemento.
Nota:Cada fragmento requer um identificador nico que o sistema pode usar
para restaurar o fragmento se a atividade for reiniciada (e que voc pode usar
para capturar o fragmento para realizar transaes, como remov-lo). Existem
trs formas para fornecer uma identificao de um fragmento:
o Fornea o android:id com um ID nico.o Fornea o android:tag com uma string nica.
o Se voc no fornecer nenhum dos dois anteriores, o sistemautiliza a identificao de exibio de recipiente.
Ou ento, programaticamente adicionar o fragmento de um j existente
ViewGroup .
A qualquer momento, enquanto sua atividade est sendo executada, voc pode
adicionar fragmentos ao seu layout. Voc s precisa especificar um ViewGroup para
colocar o fragmento.
5/25/2018 Android - Programao - Viso Geral.pdf
34/267
ANDROID, uma viso geralAnderson Duarte de Amorim 34
Para fazer transaes em sua atividade (como adicionar, remover ou substituir um
fragmento), voc deve usar as APIs do FragmentTransaction. Voc pode obter uma
instncia de FragmentTransaction de sua Activity como esta:
FragmentManagerfragmentManager =getFragmentManager()FragmentTransactionfragmentTransaction =fragmentManager.beginTransaction();
Voc pode ento adicionar um fragmento ao usar o mtodo add(),especificando o
fragmento a adicionar e a viso para inseri-lo. Por exemplo:
ExampleFragmentfragment =newExampleFragment();
fragmentTransaction.add(R.id.fragment_container,fragment);fragmentTransaction.commit();
O primeiro argumento passado para add() o ViewGroup em que o fragmento deveser colocado, especificado por identificao do recurso, e o segundo parmetro o
fragmento a acrescentar.
Depois que voc fizer as alteraes com FragmentTransaction , voc deve chamar
commit()para que as alteraes tenham efeito.
Adicionando um fragmento sem uma interface de usurio (UI)
Os exemplos acima mostram como adicionar um fragmento de sua atividade, a fim de
fornecer uma interface do usurio. No entanto, voc tambm pode usar um fragmento
para fornecer um comportamento de fundo para a atividade sem a apresentao da
interface do usurio.
Para adicionar um fragmento sem uma interface de usurio, adicione o fragmento da
atividade usando add(Fragment, String)(fornecimento de uma nica seqncia de "tag"
para o fragmento, ao invs de um ID). Isso adiciona o fragmento, mas, porque no est
associada a um ponto de vista do layout atividade, ele no recebe uma chamada para
onCreateView(). Assim voc no precisa implementar esse mtodo.
Fornecendo uma tag string para o fragmento no estritamente para os fragmentos no-
UI. Voc tambm pode fornecer etiquetas de seqncia de fragmentos que possuem
uma interface de usurio, mas se o fragmento no possui uma interface de usurio, a tag
string o nico caminho para identific-lo. Se voc deseja obter o fragmento da
atividade posterior, voc precisa usar findFragmentByTag().
http://developer.android.com/reference/android/app/Activity.html#getFragmentManager()http://developer.android.com/reference/android/app/Activity.html#getFragmentManager()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/Activity.html#getFragmentManager()5/25/2018 Android - Programao - Viso Geral.pdf
35/267
ANDROID, uma viso geralAnderson Duarte de Amorim 35
Gerenciando fragmentos
Para gerenciar os fragmentos em sua atividade, voc precisar usar FragmentManager.
Para obt-lo, chame getFragmentManager() em sua atividade.
Algumas coisas que voc pode fazer com FragmentManager incluem:
Obter fragmentos que existem na atividade, com findFragmentById() (para os
fragmentos que fornecem uma interface de usurio no layout de atividade) ou
findFragmentByTag()(para os fragmentos que fazem ou no uma interface do
usurio).
Retirar fragmentos da pilha, com popBackStack() (simulando um comando
BACK pelo usurio).
Registre-se um ouvinte de alterao de parte de trs da pilha, com
addOnBackStackChangedListener().
Conforme demonstrado na seo anterior, voc tambm pode usar FragmentManager
para abrir uma FragmentTransaction, que lhe permite realizar transaes, tais como
adicionar e remover fragmentos.
Executando transaes com fragmento
Uma das grandes novidades sobre o uso de fragmentos em sua atividade a capacidade
de adicionar, remover, substituir e realizar outras aes com eles, em resposta
interao do usurio. Cada conjunto de alteraes que comprometem a atividade
chamado de transao e voc pode executar um usando APIs em FragmentTransaction.
Voc tambm pode salvar cada transao na pilha gerenciada pela atividade, permitindo
ao usurio navegar para trs atravs das mudanas no fragmento (semelhante ao navegarpara trs por meio de atividades).
Voc pode adquirir uma instncia de FragmentTransaction do FragmentManager como
este:
FragmentManagerfragmentManager =getFragmentManager();
FragmentTransactionfragmentTransaction =fragmentManager.beginTransaction();
Cada transao um conjunto de mudanas que se deseja realizar, ao mesmo tempo.
Voc pode configurar todas as alteraes que pretendem efetuar uma operao
http://developer.android.com/reference/android/app/Activity.html#getFragmentManager()http://developer.android.com/reference/android/app/Activity.html#getFragmentManager()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/FragmentManager.html#beginTransaction()http://developer.android.com/reference/android/app/Activity.html#getFragmentManager()5/25/2018 Android - Programao - Viso Geral.pdf
36/267
ANDROID, uma viso geralAnderson Duarte de Amorim 36
determinada utilizando mtodos como add(), remove(), e replace(). Em seguida, para
aplicar a operao para a atividade, voc deve chamar commit().
Antes de chamar commit(), no entanto, voc pode querer chamar addToBackStack(), a
fim de acrescentar a operao a uma volta da pilha de transaes. Esta volta na pilha gerida pela atividade e permite que ao usurio retornar ao estado de fragmento anterior,
pressionando a tecla BACK.
Por exemplo, aqui est como voc pode substituir um fragmento a outro e preservar o
estado anterior da pilha de volta:
// Create new fragment and transactionFragmentnewFragment =newExampleFragment();
FragmentTransactiontransaction =getFragmentManager().beginTransaction();
// Replace whatever is in the fragment_container view with this fragment,// and add the transaction to the back stacktransaction.replace(R.id.fragment_container,newFragment);transaction.addToBackStack(null);
// Commit the transactiontransaction.commit();
Neste exemplo, newFragmentsubstitui qualquer fragmento (se houver) atualmente no
continer de layout identificado pelo R.id.fragment_container ID. Ao chamaraddToBackStack(), salvado na pilha de volta a operao para que o usurio possa
anular a operao e trazer de volta o fragmento anterior pressionando a tecla BACK.
Se voc adicionar vrias alteraes operao (como um outro add() ou remove()) e
chamar addToBackStack(), ento todas as mudanas aplicadas antes de chamar
commit()so adicionados volta da pilha como uma nica operao e a tecla BACK ir
inverter-los todos juntos.
A ordem na qual voc adiciona as alteraes em um FragmentTransaction no importa,
exceto:
Voc deve chamar commit()por ltimo.
Se voc est adicionando vrios fragmentos para o mesmo recipiente, ento a
ordem em que voc adicion-los determina a ordem em que aparecem na
hierarquia.
5/25/2018 Android - Programao - Viso Geral.pdf
37/267
ANDROID, uma viso geralAnderson Duarte de Amorim 37
Se voc no chamar addToBackStack() quando voc executar uma operao que
remove um fragmento, em seguida, esse fragmento destrudo quando a transao for
confirmada e o usurio no pode navegar de volta para ela. Considerando que, se voc
chamar addToBackStack() quando da remoo de um fragmento, o fragmento
interrompidoe ser retomado se o usurio navega de volta.
Dica:Para cada transao, voc pode aplicar uma animao de transio, chamando
setTransition()antes do commit().
Chamar commit()no executa a operao imediatamente. Em vez disso, ele agenda a
execuo no segmento da atividade de interface do usurio (a thread "main"), logo que
o segmento for capaz de faz-lo. Se necessrio, no entanto, voc pode chamar
executePendingTransactions() no seu segmento de interface do usurio para executar
imediatamente as operaes apresentadas por commit(). Fazer isso geralmente no
necessrio a menos que a transao uma dependncia para o emprego em outros
segmentos.
Cuidado: voc pode cometer uma transao usando commit() apenas antes da
atividade salvar seu estado (quando o usurio deixa a atividade). Se a tentativa for
cometer depois desse ponto, uma exceo ser lanada. Isso ocorre porque o estado,aps a confirmao, pode ser perdido se a atividade precisa ser restaurada. Para as
situaes em que no tem problema voc perder o commit, use
commitAllowingStateLoss().
Comunicando-se com a atividade
Ainda que um Fragmentseja implementado como um objeto que independente de uma
Activitye pode ser usado dentro de mltiplas atividades, uma determinada instncia de
um fragmento est diretamente ligada atividade que o contm.
Especificamente, o fragmento pode acessar a instncia Activity com getActivity() e
facilmente realizar tarefas como encontrar um ponto de vista do esquema de atuao:
ViewlistView =getActivity().findViewById(R.id.list);
Da mesma forma, sua atividade pode chamar mtodos no fragmento atravs da
aquisio de uma referncia para o Fragment de FragmentManager, usando
findFragmentById()ou findFragmentByTag(). Por exemplo:
http://developer.android.com/reference/android/app/Fragment.html#getActivity()http://developer.android.com/reference/android/app/Fragment.html#getActivity()http://developer.android.com/reference/android/app/Activity.html#findViewById(int)http://developer.android.com/reference/android/app/Activity.html#findViewById(int)http://developer.android.com/reference/android/app/Activity.html#findViewById(int)http://developer.android.com/reference/android/app/Activity.html#findViewById(int)http://developer.android.com/reference/android/app/Fragment.html#getActivity()5/25/2018 Android - Programao - Viso Geral.pdf
38/267
ANDROID, uma viso geralAnderson Duarte de Amorim 38
ExampleFragmentfragment =(ExampleFragment)getFragmentManager().findFragmentById(R.id.example_fragment);
Criar callbacks evento para a atividade
Em alguns casos, voc pode precisar de um fragmento de compartilhar eventos com aatividade. Uma boa maneira de fazer isso definir uma interface de retorno no interior
do fragmento e exigem que a atividade de acolhimento implemente-a. Quando a
atividade recebe uma chamada atravs da interface, ela pode compartilhar a informao
com outros fragmentos no layout conforme necessrio.
Por exemplo, se um aplicativo de notcias tem dois fragmentos de uma atividade e um
mostra uma lista de artigos (fragmento A) e outro mostra um artigo (fragmento B),
ento um fragmento deve informar a atividade quando um item da lista escolhido demodo que pode dizer ao fragmento B para exibir o artigo. Neste caso, a interface
OnArticleSelectedListener declarada dentro de um fragmento:
publicstaticclassFragmentAextendsListFragment{...// Container Activity must implement this interfacepublicinterfaceOnArticleSelectedListener{
publicvoidonArticleSelected(UriarticleUri);}
...}
Em seguida, a atividade que hospeda o fragmento implementa a
OnArticleSelectedListenere substitui onArticleSelected()para notificar o fragmento B
do evento a partir do fragmento A. Para garantir que a atividade de acolhimento
implemente essa interface, um fragmento do mtodo onAttach() de retorno (que chama
o sistema quando adicionando o fragmento para a atividade) instancia uma instncia de
OnArticleSelectedListenerpelo casting da Activityque passado para onAttach():
publicstaticclassFragmentAextendsListFragment{OnArticleSelectedListenermListener;...@OverridepublicvoidonAttach(Activityactivity){
super.onAttach(activity);try{
mListener =(OnArticleSelectedListener)activity;}catch(ClassCastExceptione){
thrownewClassCastException(activity.toString()+" must implementOnArticleSelectedListener");
}
5/25/2018 Android - Programao - Viso Geral.pdf
39/267
ANDROID, uma viso geralAnderson Duarte de Amorim 39
}...
}
Se a atividade no tenha aplicado a interface, ento o fragmento lana um
ClassCastException. Em caso de sucesso, o membro mListenermantm uma refernciapara a implementao da atividade de OnArticleSelectedListener, de modo que um
fragmento pode compartilhar eventos com a atividade, chamando os mtodos definidos
pela interface OnArticleSelectedListener. Por exemplo, se um fragmento uma
extenso do ListFragment, cada vez que o usurio clica em um item da lista, o sistema
chama onListItemClick() no fragmento, o que chama onArticleSelected() para
compartilhar o evento com a atividade:
publicstaticclassFragmentAextendsListFragment{OnArticleSelectedListenermListener;...@OverridepublicvoidonListItemClick(ListViewl,Viewv,intposition,longid){
// Append the clicked item's row ID with the content provider UriUrinoteUri =ContentUris.withAppendedId(ArticleColumns.CONTENT_URI,id);
// Send the event and Uri to the host activitymListener.onArticleSelected(noteUri);
}...
}
O parmetro id passado para onListItemClick() o ID da linha do item clicado, que a
atividade (ou outro fragmento) utiliza para buscar o artigo a partir do aplicativo
ContentProvider.
Adicionando itens barra de ao
Seus fragmentos podem contribuir itens de menu para a atividade do menu de opes (e,
conseqentemente, a Barra de ao) pela execuo onCreateOptionsMenu(). Para queesse mtodo receba chamadas, no entanto, voc deve chamar setHasOptionsMenu()
durante onCreate(), para indicar que o fragmento gostaria de adicionar itens ao menu de
opes (caso contrrio, o fragmento no ir receber uma chamada para
onCreateOptionsMenu()).
Os itens que voc adicionar ao menu de opes do fragmento so acrescentados aos
itens de menu existente. O fragmento tambm recebe callbacks para
onOptionsItemSelected()quando um item de menu selecionado.
http://developer.android.com/reference/android/content/ContentUris.html#withAppendedId(android.net.Uri,%20long)http://developer.android.com/reference/android/content/ContentUris.html#withAppendedId(android.net.Uri,%20long)http://developer.android.com/reference/android/content/ContentUris.html#withAppendedId(android.net.Uri,%20long)http://developer.android.com/reference/android/content/ContentUris.html#withAppendedId(android.net.Uri,%20long)5/25/2018 Android - Programao - Viso Geral.pdf
40/267
ANDROID, uma viso geralAnderson Duarte de Amorim 40
Voc tambm pode registrar uma exibio em seu layout para fornecer um menu de
contexto, chamando registerForContextMenu(). Quando o usurio abre o menu de
contexto, o fragmento recebe uma chamada para onCreateContextMenu(). Quando o
usurio seleciona um item, o fragmento recebe uma chamada para
onContextItemSelected().
Nota:Embora o fragmento receba um on-item-selected na chamada de retorno para
cada item de menu que acrescenta, a atividade a primeira a receber o respectivo
retorno quando o usurio seleciona um item de menu. Se a execuo da atividade da
chamada de retorno no item selecionado no lidar com o item selecionado, o evento
transmitido para retorno do fragmento. Isso verdadeiro para o menu de opes e
menus de contexto.
Manuseio do ciclo de vida do fragmento
Figura 3.O ciclo de vida afeta a atividade do ciclo de vida do fragmento.
5/25/2018 Android - Programao - Viso Geral.pdf
41/267
ANDROID, uma viso geralAnderson Duarte de Amorim 41
Gerenciar o ciclo de vida de um fragmento um pouco como gerir o ciclo de vida de
uma atividade. Como uma atividade, um fragmento pode existir em trs estados:
Retomado: O fragmento visvel na atividade de execuo.
Em pausa: Outra atividade est em primeiro plano e tem o foco, mas a atividade em que
vive esse fragmento ainda visvel (a atividade do primeiro plano parcialmente
transparente ou no cobre a tela inteira).
Parado: O fragmento no visvel. A atividade host foi parada ou o fragmento foi
retirado da atividade, mas adicionado volta da pilha. Um fragmento que parou ainda
est vivo (todas as informaes do estado e membro so mantidas pelo sistema). No
entanto, j no visvel para o usurio e sero mortos se a ativida