Android DEFINIÇÕES E CICLO DE VIDA. Prof. Dr. Joaquim assunção.

Android DEFINIÇÕES E CICLO DE VIDA Prof. Dr. Joaquim assunção.

Parte 1/2 Bases

Fundamentos Os aplicativos do Android são programados em linguagem de programação Java ou Kotlin. As ferramentas Android SDK compilam o código (em conjunto com todos os arquivos de dados e recursos) em um APK (Android PacKage). Os arquivos de APK contêm todo o conteúdo de um aplicativo do Android e são os arquivos que os dispositivos desenvolvidos para Android usam para instalar o aplicativo.

Depois de instalado (App) O sistema operacional Android é um sistema Linux multiusuário em que cada aplicativo é um usuário diferente. Por padrão, o sistema atribui a cada aplicativo um ID de usuário do Linux exclusivo (o ID é usado somente pelo sistema e é desconhecido para o aplicativo). O sistema define permissões para todos os arquivos em um aplicativo, de modo que somente o ID de usuário atribuído àquele aplicativo pode acessá-los.

Depois de instalado (App) Cada processo tem sua própria máquina virtual (VM), portanto o código de um aplicativo é executado isoladamente de outros aplicativos. Por padrão, cada aplicativo é executado em seu próprio processo Linux. O Android inicia o processo quando é preciso executar algum componente do aplicativo; em seguida, encerra-o quando não mais é necessário ou quando o sistema precisa recuperar memória para outros aplicativos.

Definições de acesso e segurança O sistema Android implementa o princípio do privilégio mínimo. Ou seja, cada aplicativo, por padrão, tem acesso somente aos componentes necessários para a execução do seu trabalho e nada mais. Isso cria um ambiente muito seguro em que o aplicativo não pode acessar partes do sistema para o qual não tem permissão.

Definições de acesso e segurança No entanto, sempre existe uma maneira de um aplicativo compartilhar dados com outros aplicativos e acessar serviços do sistema: É impossível fazer com que dois aplicativos compartilhem o mesmo ID de usuário do Linux, caso em que eles são capazes de acessar os arquivos um do outro. Para preservar os recursos do sistema, os aplicativos com o mesmo ID de usuário também podem ser combinados para serem executados no mesmo processo Linux e compartilhar a mesma VM (também é preciso atribuir o mesmo certificado aos aplicativos).

Definições de acesso e segurança Um aplicativo pode solicitar permissão para acessar dados de dispositivo como contatos do usuário, mensagens SMS, o sistema montável (cartão SD), câmera, Bluetooth etc. Todas as permissões de aplicativo devem ser concedidas pelo usuário no momento da instalação.

Definições de acesso e segurança O arquivo de manifesto em que os componentes são declarados e os recursos de dispositivo necessários ao aplicativo. Recursos separados do código do aplicativo que permitem otimizar o comportamento de uma variedade de configurações de dispositivo.

Parte 2/2 Activity

Activity (atividades) As atividades representam uma tela única com uma interface do usuário. E.g., um aplicativo de e-mails pode ter uma atividade que mostra uma lista de novos e-mails, outra atividade que compõe um e-mail e outra ainda que lê e-mails. Embora essas atividades funcionem juntas para formar uma experiência de usuário coesa no aplicativo de e-mails, elas são independentes entre si. Portanto, um aplicativo diferente pode iniciar qualquer uma dessas atividades (se o aplicativo de e-mails permitir). Por exemplo, um aplicativo de câmera pode iniciar a atividade no aplicativo de e-mail que compõe o novo e-mail para que o usuário compartilhe uma foto.

Activity Para criar uma atividade, implementa-se uma subclasse de activity, Na subclasse, é preciso implementar um método de retorno de chamada que o sistema chama quando ocorre a transição entre os diversos estados de seu ciclo de vida, como na criação, interrupção, retomada ou destruição da atividade. Os dois métodos mais importantes de retorno de chamada são: oncreate() É preciso implementar esse método. O sistema o chama ao criar a atividade. Na implementação, é preciso inicializar os componentes essenciais da atividade

Activity Para Abrir uma Activity, use um intent: Intent intent = new Intent(this, MinhaActivity.class); Depois use startactivity() startactivity(intent);

Activity Para passar dados para uma sub-activity, crie um Bundle: Bundle bun = new Bundle(); bun.putstring( Prog Mobile", com Android );

Activity onpause() O sistema chama esse método como o primeiro indício de que o usuário está saindo da atividade (embora não seja sempre uma indicação de que a atividade será destruída). É quando geralmente se deve confirmar qualquer alteração que deva persistir além da sessão do usuário atual (porque o usuário pode não retornar).

Activity public class ExampleActivity extends Activity { @Override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); // A atividade foi criada. } @Override protected void onstart() { super.onstart(); // A atividade começou, mas ainda não está visível. } @Override protected void onresume() { super.onresume(); // A atividade ficou visivel ("resumed"). } @Override protected void onpause() { super.onpause(); // Outra atividade teve foco ("paused"). } @Override protected void onstop() { super.onstop(); // A atividade parou ("stopped") } @Override protected void ondestroy() { super.ondestroy(); // A atividade vai acabar. } }

Implementação de uma interface do usuário A interface do usuário de uma atividade é fornecida por uma hierarquia de objetos de vistas derivados da classe view(). Cada view controla um espaço retangular específico dentro da janela da atividade e pode responder à interação com o usuário. Por exemplo: uma view pode ser um botão que inicia uma ação quando o usuário toca nele.

Implementação de uma interface do usuário O Android oferece algumas views prontas que podem ser usadas para projetar e organizar o layout. "Widgets" são vistas que fornecem elementos visuais (e interativos) à tela, como um botão, um campo de texto, uma caixa de seleção ou apenas uma imagem. "Layouts" são vistas derivadas de ViewGroup que oferecem um modelo de layout exclusivo para suas vistas filhas, como um layout linear, um layout em grade ou um layout relativo.

Declaração de uma atividade no manifesto É preciso declarar a atividade no arquivo de manifesto para tornála acessível para o sistema. Para declarar a atividade, abra o arquivo de manifesto e adicione um elemento activity; como filho do elemento application;. Por exemplo: <manifest... > <application... > <activity android:name=".exampleactivity" />... </application... >... </manifest >

Declaração de uma atividade no manifesto Existem outros atributos que podem ser incluídos nesse elemento para definir propriedades como o rótulo da atividade, um ícone para a atividade ou um tema para estilizar a IU da atividade. O atributo android:name é o único atributo obrigatório ele especifica o nome de classe da atividade. Depois de publicar o aplicativo, não se deve alterar-lhe o nome porque, se isso acontecer, podem ocorrer danos em algumas funcionalidades, como os atalhos do aplicativo.

Uso de filtros de intenções Um elemento activity; também pode especificar vários filtros de intenções usando o elemento intent-filter para declarar o modo com que os componentes de aplicativo podem ativá-lo. Ao criar um novo aplicativo com as ferramentas do Android SDK, o esboço da atividade criado contém automaticamente um filtro de intenção que declara que a atividade responde à ação "main" (principal) e deve ser colocada na categoria "launcher (inicializador). O filtro de intenção tem a seguinte aparência:

Uso de filtros de intenções <activity android:name=".exampleactivity" android:icon="@drawable/app_icon"> <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> O elemento action; especifica que este é o principal ponto de entrada do aplicativo. O elemento category; especifica que essa atividade deve ser listada no inicializador do aplicativo do sistema (para permitir que os usuários iniciem essa atividade).

Uso de filtros de intenções Se a ideia é ter um aplicativo seja autônomo e que não permita que outros aplicativos ativem suas atividades, não será necessário nenhum outro filtro de intenção. Só uma atividade deve ter a ação "main" e a categoria "launcher", como no exemplo anterior. As atividades que não devem estar disponíveis a outros aplicativos não devem ter filtros de intenção, já que é possível iniciá-las por meio de intenções explícitas.

Uso de filtros de intenções No entanto, se a atividade deve responder a intenções implícitas derivadas de outros aplicativos (e do aplicativo em questão), é preciso definir filtros de intenções adicionais para a atividade. Para cada tipo de intenção que deve responder, é preciso incluir um intent-filter; que contenha um elemento action e, opcionalmente, um elemento category; e/ou um elemento data;. Esses elementos especificam o tipo de intenção a que a atividade pode responder.

Início de uma atividade Para iniciar outra atividade, é possível chamar startactivity() passando uma Intent que descreva a atividade que se deseja iniciar. A intenção especifica a atividade exata que deve ser iniciada ou descreve o tipo de ação que ela deve executar (e o sistema seleciona a atividade adequada, que pode ser até de um outro aplicativo). Uma intenção também pode portar pequenas quantidades de dados a serem usados pela atividade iniciada. Ao trabalhar no aplicativo, frequentemente será necessário iniciar uma atividade conhecida. Para isso, pode-se criar uma intenção que defina explicitamente a atividade que deve ser iniciada por meio de um nome de classe.

Início de uma atividade Inicia-se uma nova atividade chamada SignInActivity. Intent intent = new Intent(this, SignInActivity.class); startactivity(intent);

Início de uma atividade No entanto, o aplicativo também pode ter que executar algumas ações, como enviar um e-mail, mensagem de texto ou atualização de status usando os dados da atividade em questão. Nesse caso, o aplicativo pode não ter suas próprias atividades para executar tais ações; para isso, pode-se aproveitar as atividades fornecidas por outros aplicativos do dispositivo que podem executar essas ações.

Início de uma atividade Esses são os casos em que as intenções são muito importantes é possível criar uma intenção que descreva uma ação a executar, para que o sistema inicie a atividade apropriada de outro aplicativo. Se houver mais de uma atividade que possa manipular a intenção, o usuário poderá escolher qual usará. Por exemplo: se quiser que o usuário envie uma mensagem de e-mail, é possível criar a seguinte intenção:

Optionally, you can set some standard extras for the intent: EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC, EXTRA_SUBJECT. If the receiving application is not designed to use them, it simply ignores them. Início de uma atividade Intent intencaodeenviar = new Intent(); intencaodeenviar.setaction(intent.action_send); intencaodeenviar.putextra(intent.extra_text, "Vou enviar isto."); intencaodeenviar.settype("text/plain"); startactivity(intencaodeenviar); Opcionalmente, você pode definir alguns extras para a intenção: EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC, EXTRA_SUBJECT. Se o aplicativo de recebimento não for projetado para usá-los, ele simplesmente os ignora. Nessa situação, a atividade do aplicativo de e-mail inicia e, quando o usuário termina o trabalho, sua atividade é retomada.

Início de uma atividade pra um resultado Às vezes, é necessário receber um resultado de alguma atividade iniciada. Nesse caso, inicie a atividade chamando startactivityforresult() (em vez de startactivity()). Para receber o resultado de uma atividade subsequente, implemente o método de retorno de chamada onactivityresult(). Quando a atividade subsequente estiver concluída, ela retornará um resultado em uma Intent para o método onactivityresult(). Por exemplo, talvez você queira que o usuário escolha um dos contatos dele, deste modo, a atividade poderá fazer algo com as informações naquele contato. A seguir expõe-se como criar uma intenção desse tipo e manipular o resultado:

Início de uma atividade pra um resultado private void pickcontact() { // Cria uma intensão para escolher um contato, definido pelo content provider URI Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI); //startactivityforresult(intent, PICK_CONTACT_REQUEST); OLD startactivityforresult(intent, 1); } @Override protected void onactivityresult(int requestcode, int resultcode, Intent data) { // Se tudo deu certo (OK) e a requisição foi PICK_CONTACT_REQUEST if (resultcode == Activity.RESULT_OK && requestcode == PICK_CONTACT_REQUEST) { // Consulta ao contact's content provider para o nome do contato Cursor cursor = getcontentresolver().query(data.getdata(), new String[] {Contacts.DISPLAY_NAME}, null, null, null); if (cursor.movetofirst()) { // True se o cursor não estiver vasio int columnindex = cursor.getcolumnindex(contacts.display_name); String name = cursor.getstring(columnindex); // Faça algo com o nome do contato } } }

Manifeste-se <uses-permission android:name="android.permission.read_contacts" />

Início de uma atividade pra um resultado Esse exemplo mostra a lógica básica que deve ser usada no método onactivityresult() para manipular o resultado de uma atividade. A primeira condição verifica se a solicitação foi bemsucedida se for, o resultcode será RESULT_OK e se a solicitação a que esse resultado responderá for desconhecida, nesse caso, o requestcode corresponderá ao segundo parâmetro com startactivityforresult(). Nesse momento, um ContentResolver executa uma consulta em um provedor de conteúdo, que retorna um Cursor que permite a leitura dos dados consultados.

Encerramento de uma atividade Para encerrar uma atividade, chame o método finish(). Também é possível encerrar uma atividade separada iniciada anteriormente chamando finishactivity(). Cuidado! O Android gerencia o termino dos aplicativos, estes métodos não são necessários na grande maioria dos casos.

Gravação do estado da atividade Quando uma atividade é pausada ou interrompida, o estado da atividade é retido. Isso acontece porque o objeto Activity continua mantido na memória quando a atividade está pausada ou interrompida todas as informações sobre seus membros e estado atual ainda estão ativas. Todas as alterações feitas pelo usuário dentro da atividade são retidas, de forma que, quando a atividade retornar ao primeiro plano (quando é "retomada"), essas alterações ainda estejam lá.

Gravação do estado da atividade No entanto, quando o sistema destrói uma atividade para recuperar memória, o objeto Activity é destruído, por isso o sistema não pode simplesmente retomá-la com seu estado intacto. Em vez disso, o sistema tem que recriar o objeto Activity se o usuário navegar de volta a ele. Ainda assim, o usuário não estará ciente de que o sistema destruiu a atividade e recriou-a e, assim, provavelmente esperará que a atividade esteja exatamente como antes. Para garantir que as informações importantes sobre o estado da atividade sejam preservadas, implementa-se um método adicional de retorno de chamada que permite salvar as informações sobre o estado da atividade: onsaveinstancestate().

Gravação do estado da atividade...o sistema chama onsaveinstancestate() antes de deixar a mensagem vulnerável à destruição. O sistema passa a esse método um Bundle no qual é possível salvar informações de estado acerca da atividade, como pares nomevalor, usando métodos como putstring() e putint(). Em seguida, se o sistema eliminar o processo do aplicativo e o usuário voltar à atividade, o sistema recriará a atividade e passará o Bundle a oncreate() e a onrestoreinstancestate().

Gravação do estado da atividade Usando qualquer um desses métodos, é possível extrair o estado salvo de Bundle e restaurar o estado da atividade. Se não houver informações de estado a restaurar, o Bundle passado será nulo (que é o caso quando a atividade é criada pela primeira vez).

Gravação do estado da atividade Se você não fizer nada e não implementar onsaveinstancestate(), parte do estado da atividade será restaurada pela implementação padrão da classe Activity de onsaveinstancestate(). Especificamente, a implementação padrão chama o método onsaveinstancestate() correspondente para cada View no layout, o que permite que cada vista forneça informações próprias sobre o que deve ser salvo.

Gravação do estado da atividade