Contente
- O que são widgets para Android?
- Meu projeto realmente precisa de um widget de aplicativo?
- Os widgets para Android podem melhorar a experiência do usuário
- Mais poderoso que os atalhos de aplicativos
- Crie um widget Android para impulsionar o envolvimento a longo prazo
- Criando um widget de aplicativo de coleção
- Construindo o layout do seu widget
- Preenchendo o Widget de Coleção
- AppWidgetProvider: configurando seu widget
- Crie o adaptador
- Definindo os métodos do ciclo de vida do widget
- Recuperando novo conteúdo com onUpdate
- onEnabled: Executando a configuração inicial
- Limpando, com onDisabled
- O AppWidgetProvider concluído
- O arquivo AppWidgetProviderInfo
- 1. android: previewImage
- 2. android: widgetCategory
- 3. android: initialLayout
- 4. android: resizeMode = "horizontal | vertical"
- 5. android: minHeight e android: minWidth
- 6. android: updatePeriodMillis
- O AppWidgetProviderInfo concluído
- Não desorganize a tela inicial do usuário!
- Enviando dados para o widget
- Registrando seu widget no manifesto
- Coloque seu widget à prova
- Criando uma imagem de visualização do widget Android
- Widgets personalizáveis: Incluindo uma Configuração
- Crie a atividade de configuração
- Testando seu projeto
- Empacotando
Desde os primeiros dias do sistema operacional, os widgets para Android permitem que os usuários se envolvam com seus aplicativos favoritos, no conforto de sua tela inicial. Então, como você cria um widget Android?
Para o desenvolvedor, os widgets dão ao seu aplicativo uma presença valiosa na tela inicial do usuário. Em vez de ficarem escondidos na gaveta do aplicativo, os usuários serão lembrados sobre o seu aplicativo toda vez eles olham para a tela inicial - enquanto também obtêm uma visualização do conteúdo mais interessante e útil do seu aplicativo.
Os widgets dão ao seu aplicativo uma presença valiosa na tela inicial do usuário
Neste artigo, mostrarei como fornecer uma melhor experiência ao usuário, incentivando os usuários a se envolverem com seu aplicativo, criando um widget Android! Até o final deste artigo, você criou um widget de coleção rolável que exibe um conjunto de dados completo na tela inicial do usuário.
Para garantir que você esteja fornecendo o tipo de widget que os usuários quer para colocar na tela inicial, também criaremos uma atividade de configuração, que permitirá aos usuários personalizar o conteúdo, a aparência e os recursos do widget. Por fim, mostrarei como você pode incentivar as pessoas a usar seu widget, criando uma imagem de Visualização de widget que mostra o melhor que seu widget tem para oferecer.
Leia também: Desenvolvendo para dispositivos dobráveis: o que você precisa saber
O que são widgets para Android?
Um widget de aplicativo é um aplicativo leve e em miniatura que fica na tela inicial do usuário.
Os widgets para Android podem fornecer uma variedade de conteúdo, mas geralmente se enquadram em uma das seguintes categorias:
- Widget de informações. Este é um widget não rolável que exibe algumas informações, como a previsão do tempo de hoje ou a data e hora.
- Widgets de coleção. Este é um widget rolável que exibe um conjunto de dados relacionados, formatado como ListView, GridView, StackView ou AdapterViewFlipper. Os widgets de coleção geralmente são apoiados por uma fonte de dados, como um banco de dados ou uma matriz.
- Controlar widgets. Esses widgets agem como um controle remoto que permite aos usuários interagir com seu aplicativo, sem ter que trazê-lo para o primeiro plano. Os aplicativos que reproduzem mídia, como podcasts ou música, geralmente possuem widgets de controle que permitem ao usuário disparar ações de Reproduzir, Pausar e Ignorar diretamente da tela inicial.
- Widgets híbridos. Às vezes, você pode oferecer uma melhor experiência ao usuário combinando elementos de várias categorias. Por exemplo, se você estiver desenvolvendo um widget de controle para um aplicativo de música, poderá fornecer os controles Reproduzir, Pausar e Ignorar, mas também poderá exibir algumas informações, como o título e o artista da música. Se você decidir misturar e combinar, não se empolgue! Os widgets tendem a oferecer a melhor experiência do usuário quando fornecem acesso fácil a uma pequena quantidade de informações relevantes e oportunas ou a alguns recursos comumente usados. Para ajudar a manter seus widgets híbridos leves, é recomendável identificar a categoria principal do widget, desenvolvê-lo de acordo com essa categoria e então adicione alguns elementos da categoria secundária do widget.
Meu projeto realmente precisa de um widget de aplicativo?
Há vários motivos pelos quais você deve considerar adicionar um widget de aplicativo ao seu projeto Android.
Os widgets para Android podem melhorar a experiência do usuário
Como regra geral, quanto menos etapas de navegação forem necessárias para concluir uma tarefa, melhor a experiência do usuário.
Ao fornecer um widget de aplicativo, você pode remover várias etapas de navegação dos fluxos mais usados do seu aplicativo. Na melhor das hipóteses, seus usuários poderão obter as informações necessárias apenas olhando para a tela inicial ou executar a tarefa desejada simplesmente tocando em um botão no widget de controle.
Mais poderoso que os atalhos de aplicativos
Os widgets de aplicativos geralmente respondem a eventos onClick iniciando o nível superior no aplicativo associado, semelhante a um atalho do aplicativo. No entanto, os widgets também podem fornecer acesso direto a atividades específicas em um aplicativo, por exemplo, ao tocar na notificação Novo recebimento de um widget, é possível iniciar o aplicativo associado ao novo já aberto.
Ao incorporar vários links no layout do seu widget, você pode fornecer acesso com um toque a todas as atividades mais importantes do seu aplicativo, removendo ainda mais etapas de navegação dos seus fluxos mais usados.
Ao incorporar vários links no layout do seu widget, você pode fornecer acesso com um toque a todas as atividades mais importantes do seu aplicativo.
Observe que os widgets respondem apenas aos eventos onClick, o que impede que os usuários interajam acidentalmente com o widget enquanto percorrem a tela inicial. A única exceção é quando o usuário tenta excluir seu widget, arrastando-o para a ação Remover da tela inicial, pois nesse cenário, o widget responderá a um gesto de furto vertical.
Essa interação é gerenciada pelo sistema Android, portanto, você não precisa se preocupar em implementar manualmente o suporte de furto vertical no seu widget.
Crie um widget Android para impulsionar o envolvimento a longo prazo
Convencer as pessoas a baixar o seu aplicativo é apenas o primeiro passo para criar um aplicativo Android de sucesso. As chances são de que, se você pegar seu próprio smartphone ou tablet Android e deslizar pela gaveta do aplicativo, descobrirá vários aplicativos que não usa há dias, semanas ou potencialmente até meses!
Leia também:Introdução ao SDK do Facebook para Android
Depois que seu aplicativo for instalado com sucesso no dispositivo do usuário, você precisará trabalhar duro para mantê-lo envolvido e desfrutando do aplicativo. A presença do seu aplicativo na tela inicial pode ser uma ferramenta poderosa para ajudar a impulsionar o envolvimento a longo prazo, simplesmente porque é um lembrete constante de que o seu aplicativo existe!
Um widget bem projetado também pode servir como um anúncio contínuo para seu aplicativo. Sempre que o usuário olha para a tela inicial, seu widget tem a oportunidade de incentivá-lo ativamente a se envolver novamente com seu aplicativo, apresentando a ele todo o conteúdo mais interessante e útil de seu aplicativo.
Criando um widget de aplicativo de coleção
Neste tutorial, criaremos um widget de coleção que exibe uma matriz como um ListView rolável.
Para ajudar a rastrear o ciclo de vida do widget do aplicativo, esse widget também acionará várias brindes à medida que ele se move pelos diferentes estados do ciclo de vida. No final deste tutorial, aprimoraremos nosso widget com uma imagem de visualização personalizada que será exibida no Seletor de widgets do Android e uma atividade de configuração, que permitirá aos usuários personalizar o widget antes de colocá-lo na tela inicial.
Crie um novo projeto Android com as configurações de sua escolha e vamos começar!
Construindo o layout do seu widget
Para começar, vamos definir a interface do usuário do widget.
Os widgets de aplicativos são exibidos em um processo lado de fora seu aplicativo, para que você possa usar apenas layouts e exibições compatíveis com os RemoteViews.
Ao criar seu layout, você se restringe ao seguinte:
- Relógio analógico
- Botão
- Cronômetro
- FrameLayout
- GridLayout
- ImageButton
- ImageView
- LinearLayout
- Barra de progresso
- Esquema relativo
- TextView
- ViewStub
- AdapterViewFlipper
- GridView
- Exibição de lista
- StackView
- ViewFlipper
Observe que as subclasses das classes e visualizações acima são não suportado.
Crie um novo arquivo de recurso de layout chamado list_widget.xml. Como exibiremos nossos dados usando um ListView, esse layout serve principalmente como um contêiner para um Em seguida, precisamos criar um provedor de dados para o nosso ListView. Crie uma nova classe Java denominada DataProvider.java e adicione o seguinte: importar android.content.Context; importar android.content.Intent; importar android.widget.RemoteViews; importar android.widget.RemoteViewsService; importar java.util.ArrayList; importar java.util.List; importar android.R.id.text1 estático; importar android.R.layout.simple_list_item_1 estático; classe pública DataProvider implementa RemoteViewsService.RemoteViewsFactory {List Para criar um widget Android, você precisa criar vários arquivos. Nosso primeiro arquivo específico do widget é um AppWidgetProvider, que é um BroadcastReceiver, onde você define os vários métodos de ciclo de vida do widget, como o método chamado quando o widget é criado pela primeira vez e o método chamado quando o widget é finalmente excluído. Crie uma nova classe Java (Arquivo> Novo> Classe Java) denominada CollectionWidget. Para começar, todos os arquivos do provedor de widget devem se estender da classe AppWidgetProvider. Em seguida, precisamos carregar o arquivo de recurso de layout list_widget.xml em um objeto RemoteViews e informar o AppWidgetManager sobre o objeto RemoteViews atualizado: classe pública CollectionWidget estende AppWidgetProvider {static void updateAppWidget (Contexto do contexto, AppWidgetManager appWidgetManager, int appWidgetId) {// Instancia o objeto RemoteViews // Exibições RemoteViews = new RemoteViews (context.getPackageName (), R.layout.list_widget); setRemoteAdapter (contexto, visualizações); // Solicita que o AppWidgetManager atualize o widget do aplicativo // appWidgetManager.updateAppWidget (appWidgetId, views); } Como exibimos nossos dados em um ListView, precisamos definir um método setRemoteAdapter () em nosso AppWidgetProvider. O setRemoteAdapter () é equivalente a chamar AbsListView.setRemoteViewsAdapter (), mas foi projetado para ser usado em widgets de aplicativos. Nesse método, precisamos definir o ID do AdapterView (R.id.widget_list) e a intenção do serviço que fornecerá os dados ao nosso RemoteViewsAdapter - criaremos em breve essa classe WidgetService. private static void setRemoteAdapter (Contexto de contexto, exibições RemoteViews finais do @NonNull) {views.setRemoteAdapter (R.id.widget_list, new Intent (contexto, WidgetService.class)); }} Em nosso AppWidgetProvider, também precisamos definir os seguintes métodos de ciclo de vida do widget: O método do ciclo de vida do widget onUpdate () é responsável por atualizar as visualizações do seu widget com novas informações. Este método é chamado sempre: Também é aqui que você registra qualquer manipulador de eventos que seu widget deve usar. Ao atualizar um widget Android, é importante lembrar que os usuários podem criar várias instâncias do mesmo widget. Por exemplo, talvez seu widget seja personalizável e o usuário decida criar várias "versões" que exibam informações diferentes ou forneçam acesso a funcionalidades exclusivas. Ao ligar para onUpdate (), é necessário especificar se você está atualizando todas as instâncias deste widget ou apenas uma instância específica. Se você deseja atualizar todas as instâncias, pode usar o appWidgetIds, que é uma matriz de IDs que identifica todas as instâncias no dispositivo. No snippet a seguir, estou atualizando todas as instâncias: @Override public void onUpdate (Contexto do contexto, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {// Atualize todas as instâncias deste widget // updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (contexto, appWidgetManager, appWidgetIds); } Observe que, para ajudar a manter o código direto, este método onUpdate () não está atualmente fazendo alterações no widget. O método do ciclo de vida onEnabled () é chamado em resposta a ACTION_APPWIDGET_ENABLED, enviado quando uma instância do seu widget é adicionada à tela inicial para o primeiro Tempo. Se o usuário criar duas instâncias do seu widget, onEnabled () será chamado para a primeira instância, mas não para o segundo. O método do ciclo de vida onEnabled () é onde você deve executar qualquer configuração necessária para todas as instâncias do seu widget, como criar o banco de dados que alimentará as informações do widget. Vou exibir um brinde, para que você possa ver exatamente quando esse método do ciclo de vida é chamado: @ Substituir public void onEnabled (contexto de contexto) {Toast.makeText (contexto, "onEnabled chamado", Toast.LENGTH_LONG) .show (); } Observe que, se o usuário excluir todas as instâncias do seu widget e criar uma nova instância, ela será classificada como a primeira instância e o método do ciclo de vida onEnabled () será chamado novamente. O método onDisabled () é chamado em resposta a ACTION_APPWIDGET_DISABLED, que é acionado quando o usuário exclui o último instância do seu widget. Esse método de ciclo de vida do widget é onde você deve limpar todos os recursos criados no método onEnabled (), por exemplo, excluir o banco de dados criado em onEnabled (). Para ajudar a manter nosso código simples, mostrarei um brinde toda vez que esse método for acionado: @Override public void onDisabled (Contexto do contexto) {Toast.makeText (contexto, "onDisabled chamado", Toast.LENGTH_LONG) .show (); } Seu arquivo CollectionWidget agora deve ser algo como isto: importar android.appwidget.AppWidgetManager; importar android.appwidget.AppWidgetProvider; importar android.content.Context; import androidx.annotation.NonNull; importar android.content.Intent; importar android.widget.RemoteViews; importar android.widget.Toast; // Estende da classe AppWidgetProvider // a classe pública CollectionWidget estende AppWidgetProvider {static void updateAppWidget (Contexto do contexto, AppWidgetManager appWidgetManager, int appWidgetId) {// Carrega o arquivo de recurso de layout em um objeto RemoteViews // RemoteViews views = new RemoteViews (context. getPackageName (), R.layout.list_widget); setRemoteAdapter (contexto, visualizações); // Informe o AppWidgetManager sobre o objeto RemoteViews // appWidgetManager.updateAppWidget (appWidgetId, views); } @Override public void onUpdate (Contexto do contexto, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (contexto, appWidgetManager, appWidgetIds); } @ Substituir public void onEnabled (contexto de contexto) {Toast.makeText (contexto, "onEnabled chamado", Toast.LENGTH_LONG) .show (); } @ Substituir public void onDisabled (contexto de contexto) {Toast.makeText (contexto, "onDisabled chamado", Toast.LENGTH_LONG) .show (); } void estático privado setRemoteAdapter (Contexto de contexto, visualizações finais de RemoteViews do @NonNull) {views.setRemoteAdapter (R.id.widget_list, new Intent (contexto, WidgetService.class)); }} O widget do aplicativo também requer um arquivo AppWidgetProviderInfo, que define várias propriedades importantes, incluindo as dimensões mínimas do widget e a frequência com que ele deve ser atualizado. O arquivo AppWidgetProviderInfo é armazenado na pasta res / xml do seu projeto. Se o seu projeto ainda não contiver esta pasta, será necessário criá-la: Em seguida, crie um arquivo collection_widget_info, que usaremos como nosso AppWidgetProviderInfo: Em nosso arquivo AppWidgetProviderInfo, precisamos definir as seguintes propriedades: Este é o drawable que representa o widget do seu aplicativo no Seletor de widgets do dispositivo.Preenchendo o Widget de Coleção
AppWidgetProvider: configurando seu widget
Crie o adaptador
Definindo os métodos do ciclo de vida do widget
Recuperando novo conteúdo com onUpdate
onEnabled: Executando a configuração inicial
Limpando, com onDisabled
O AppWidgetProvider concluído
O arquivo AppWidgetProviderInfo
1. android: previewImage
Se você não fornecer uma previewImage, o Android usará o ícone do seu aplicativo. Para incentivar os usuários a selecionar seu widget no Seletor de widgets, forneça um desenho que mostre a aparência do widget depois de configurado corretamente na tela inicial do usuário.
A maneira mais fácil de criar uma imagem de visualização é usar o aplicativo de Visualização de Widget incluído no emulador do Android. Este aplicativo permite configurar seu widget e gerar uma imagem, que você pode usar no seu projeto Android.
Criaremos esta imagem assim que terminarmos de criar nosso widget. Por enquanto, usarei o recurso mipmap / ic_launcher gerado automaticamente como uma imagem de visualização temporária.
2. android: widgetCategory
Os widgets de aplicativos devem ser colocados dentro de um App Widget Host, que geralmente é a tela inicial padrão do Android, mas também pode ser um lançador de terceiros, como Evie Launcher ou Nova Launcher.
Entre os níveis 17 e 20 da API, foi possível colocar os widgets de aplicativos na tela inicial ou a tela de bloqueio, mas o suporte à tela de bloqueio foi preterido no nível 21 da API.
Você pode especificar se o widget do aplicativo pode ser colocado na tela inicial, na tela de bloqueio (ao qual o Android se refere como "proteção do teclado") ou em ambos, usando o atributo android: widgetCategory. Como não é possível colocar widgets na tela de bloqueio nas versões mais recentes do Android, segmentaremos apenas a tela inicial.
Para preservar a privacidade do usuário, seu widget não deve exibir informações confidenciais ou privadas quando colocadas na tela de bloqueio.
Se você der aos usuários a opção de colocar seu widget na tela de bloqueio, qualquer pessoa que olhar para o dispositivo do usuário poderá ver seu widget e todo o seu conteúdo. Para ajudar a preservar a privacidade do usuário, seu widget não deve exibir nenhuma informação confidencial ou confidencial quando colocada na tela de bloqueio. Se o seu widget contiver dados pessoais, considere o fornecimento de layouts separados para a tela inicial e a tela de bloqueio.
3. android: initialLayout
Esse é o arquivo de recurso de layout que seu widget deve usar quando for colocado na tela inicial, que para o nosso projeto é list_widget.xml.
4. android: resizeMode = "horizontal | vertical"
O atributo android: resizeMode permite especificar se o widget pode ser redimensionado horizontalmente, verticalmente ou ao longo dos dois eixos.
Para garantir que seu widget seja exibido e funcione corretamente em uma variedade de telas, é recomendável que você redimensione horizontalmente seu widget e verticalmente, a menos que você tenha um motivo específico para não fazê-lo.
5. android: minHeight e android: minWidth
Se o seu widget for redimensionável, você precisará garantir que o usuário não reduza seu widget até o ponto em que ele se torne inutilizável. Você pode usar os atributos minHeight e minWidth para definir o menor que o aplicativo diminuirá quando for redimensionado pelo usuário.
Esses valores também representam o tamanho inicial do widget, por isso, se o widget não for redimensionável, minHeight e minWidth definirão o dimensionamento permanente do widget.
6. android: updatePeriodMillis
O AppWidgetProviderInfo também é onde você especifica com que frequência o widget deve solicitar novas informações.
O menor intervalo de atualização suportado é uma vez a cada 1800000 milissegundos (30 minutos). Mesmo se você declarar um intervalo de atualização mais curto, seu widget ainda será atualizado apenas uma vez a cada meia hora.
Embora você possa exibir as informações mais recentes o mais rápido possível, o sistema vai acorde um dispositivo adormecido para recuperar novas informações. As atualizações frequentes podem queimar a bateria de um dispositivo, principalmente durante períodos em que o dispositivo fica ocioso por um período significativo de tempo, como durante a noite. Fornecer a melhor experiência possível ao usuário significa encontrar um equilíbrio entre limitar o consumo da bateria e fornecer novas informações dentro de um prazo razoável.
Você também deve levar em consideração o tipo de conteúdo que seu widget exibirá.
Você também deve levar em consideração o tipo de conteúdo que seus widgets para Android exibirão. Por exemplo, um widget do tempo pode precisar recuperar uma previsão atualizada apenas uma vez por dia, enquanto um aplicativo que exibe as últimas notícias precisará ser atualizado com mais frequência.
Para encontrar esse equilíbrio perfeito, pode ser necessário testar seu widget em uma variedade de frequências de atualização e medir o impacto na vida útil da bateria e a pontualidade do conteúdo do widget. Se você tiver um grupo de testadores disposto, poderá configurar o teste A / B para ver se algumas frequências de atualização são recebidas mais positivamente do que outras.
Também leia: AndroidManifest.xml tudo o que você precisa saber
Por fim, depois de identificar o intervalo de atualização perfeito, convém usar um intervalo mais curto ao desenvolver e testar seu aplicativo. Por exemplo, você pode usar a menor frequência de atualização possível (android: updatePeriodMillis = "1800000") ao testar se o método onUpdate () do seu aplicativo está sendo acionado corretamente e depois alterar esse valor antes de liberá-lo para o público em geral.
O AppWidgetProviderInfo concluído
O arquivo collection_widget_info.xml concluído deve ser algo como isto:
Não desorganize a tela inicial do usuário!
Para garantir que a tela inicial nunca pareça bagunçada, adicionaremos algum preenchimento e margens ao nosso widget. Se o seu projeto ainda não tiver um arquivo dimens.xml, será necessário criar um:
- Clique com a tecla Control pressionada na pasta de valores do seu projeto.
- Selecione Novo> Arquivo de Recurso Valores.
- Atribua a esse arquivo o nome escurece.
- Clique OK.
Abra o arquivo dimens.xml e defina os seguintes valores de margem e preenchimento:
Enviando dados para o widget
Em seguida, precisamos criar um serviço de widget, que será responsável por enviar nossos dados de coleção para o widget.
Crie uma nova classe Java (Nova> Classe Java) denominada WidgetService e adicione o seguinte:
importar android.content.Intent; importar android.widget.RemoteViewsService; classe pública WidgetService estende RemoteViewsService {@Override public RemoteViewsFactory onGetViewFactory (intenção de intenção) {retorna novo DataProvider (this, intent); }}
Registrando seu widget no manifesto
Agora, precisamos fazer algumas alterações no manifesto do nosso projeto.
Para começar, abra o Manifest e registre seu widget como um BroadcastReceiver. Também precisamos adicionar um filtro de intenção para a ação android.appwidget.action.APPWIDGET_UPDATE:
Em seguida, você precisa especificar o provedor de widget do aplicativo:
Finalmente, precisamos declarar o serviço que enviará dados ao nosso widget, que nesta instância é a classe WidgetService. Este serviço requer a permissão android.permission.BIND_REMOTEVIEWS:
Coloque seu widget à prova
Se você seguiu este tutorial, agora terá um widget de coleção completo que exibe um conjunto de dados na tela inicial do usuário.
Se esse era um projeto Android da vida real, você normalmente expandia os métodos do ciclo de vida, principalmente o método onUpdate (), mas é tudo o que precisamos para criar um widget que você possa instalar e testar no seu dispositivo Android:
- Instale este projeto em um smartphone, tablet ou AVD (dispositivo virtual Android) compatível com Android.
- Pressione e segure qualquer seção vazia da tela inicial e selecione Widgets quando solicitado; isso inicia o Widget Picker.
- Passe o dedo pelo Selecionador de widgets até encontrar o widget de aplicativo que você acabou de criar.
- Pressione e segure este widget para adicioná-lo à sua tela inicial.
- Como esta é a primeira instância desse widget em particular, o método onEnabled () deve ser executado e você verá um brinde "onEnabled chamado".
- Redimensione seu widget. Se você definir um tamanho mínimo suportado, verifique se não pode reduzir o widget além desse valor.
- Teste se o ListView rola, conforme o esperado.
- Em seguida, você deve verificar o método onDisabled (), excluindo seu widget. Pressione e segure o widget e selecione Remover da tela inicial. Como esta é a última instância desse widget em particular, o método onDisabled () deve ser executado e você verá um brinde "onDisabled chamado".
Isso é tudo o que você precisa para fornecer um widget de aplicativo Android em funcionamento, mas há algumas adições que podem melhorar a experiência do usuário. Nas seções a seguir, incentivaremos os usuários a escolher esse widget no Seletor de widgets, criando uma imagem de visualização que mostre o melhor da widget. Também mostrarei como criar um widget totalmente personalizável, adicionando uma atividade de configuração ao seu projeto.
Criando uma imagem de visualização do widget Android
Se você pegar seu dispositivo Android e passar o dedo no Seletor de widgets, verá que todos os widgets são representados por uma imagem, o que geralmente demonstra como esse widget será exibido depois de configurado na tela inicial do usuário.
Para incentivar os usuários a selecionar seu widget, forneça uma imagem de visualização que destaque todas as informações e recursos úteis que seu widget tem a oferecer.
Você pode criar de maneira rápida e fácil uma imagem de visualização, usando o aplicativo Visualização de Widget, incluído no emulador do Android.
Observe que a Visualização do widget não está incluída nas imagens mais recentes do sistema Android, portanto, você precisará criar um AVD usando o Nougat (API Nível 25) ou anterior:
- Instale seu aplicativo em um AVD que esteja executando a API 25 ou inferior.
- Abra a gaveta de aplicativos do AVD e inicie o aplicativo de visualização de widget.
- A Visualização do widget exibirá uma lista de todos os aplicativos que estão atualmente instalados neste AVD; selecione seu aplicativo na lista.
- Seu widget agora será exibido em um plano de fundo em branco. Passe algum tempo redimensionando e aprimorando seu widget até mostrar o melhor que ele pode oferecer.
- Quando estiver satisfeito com a aparência e o conteúdo do seu widget, selecione Tirar instantâneo.
- Para recuperar seu instantâneo, volte para o Android Studio e selecione Exibir> Janelas de ferramentas> Explorador de arquivos do dispositivo na barra de ferramentas. Isso inicia o Device File Explorer do Android Studio.
- No Device File Explorer, navegue até sdcard / Download. Você deve encontrar sua imagem de visualização salva no seguinte formato: _ori_.png
- Arraste esta imagem para fora do Android Studio e solte-a em um local facilmente acessível, como na área de trabalho.
- Atribua a esse arquivo de imagem um nome descritivo.
- Arraste e solte o arquivo na pasta de desenho do seu projeto.
- Abra seu AppWidgetProviderInfo, que para este projeto é collection_widget_info.xml.
- Encontre a linha android: previewImage = ”@ mipmap / ic_launcher” e atualize-a para referenciar sua imagem de visualização.
Seu widget agora usará esse novo recurso de imagem como imagem de visualização:
- Instale o projeto atualizado no seu dispositivo Android físico ou no AVD.
- Pressione e segure qualquer seção vazia da tela inicial.
- Toque em Widgets, que inicia o Widget Picker.
- Role para o seu widget; agora deve estar usando a imagem de visualização atualizada.
Widgets personalizáveis: Incluindo uma Configuração
Uma Atividade de configuração é iniciada automaticamente quando o usuário coloca cada instância do seu widget na tela inicial.
Há vários motivos pelos quais você pode querer adicionar uma atividade de configuração ao seu projeto.
os widgets tendem a fornecer a melhor experiência do usuário quando fornecem acesso às informações ou recursos mais importantes para o usuário individual.
Em primeiro lugar, alguns widgets exigem configuração inicial, por exemplo, um widget que exibe alertas de tráfego pode precisar saber o endereço residencial do usuário, onde ele trabalha e os horários em que ele normalmente se desloca. Sem alguma maneira de inserir essas informações, seu widget pode ser completamente inútil!
Além disso, os widgets tendem a fornecer a melhor experiência do usuário quando fornecem acesso às informações ou recursos mais importantes para o usuário individual. Ao adicionar uma atividade de configuração ao seu projeto, você pode dar aos usuários a liberdade de escolher exatamente o que está incluído no seu widget.
Mesmo personalizações relativamente simples, como alterar o plano de fundo ou a fonte de um widget, podem ter um impacto positivo na experiência do usuário - afinal, ninguém vai gostar de um widget que se choca visualmente com o restante da tela inicial!
Ninguém vai apreciar um widget que se choca visualmente com o restante da tela inicial!
Como alternativa, às vezes você pode ter uma longa lista de conteúdo que deseja incluir no seu widget e está lutando para restringir suas opções. Uma atividade de configuração pode ser uma maneira de usar todas as suas idéias, sem criando um widget confuso e confuso. Lembre-se de que a configuração de um widget não deve parecer uma tarefa árdua; portanto, se você fornecer uma atividade de configuração, é recomendável limitar-se a três opções de configuração.
Vamos adicionar uma atividade de configuração ao nosso projeto!
Primeiramente, nossa atividade de configuração precisa de um layout; portanto, crie um novo arquivo de recurso de layout chamado config_activity.xml.
Vou adicionar os seguintes botões a este layout:
- Um botão de configuração. Em um projeto da vida real, esse botão modifica o widget de alguma maneira, por exemplo, adicionando ou removendo conteúdo ou alterando a frequência com que o widget é atualizado. Para ajudar a manter nosso código simples, clicar neste botão exibirá simplesmente um brinde às Opções de Configuração.
- Um botão de configuração. Quando o usuário estiver satisfeito com a configuração do widget, pressionar esse botão colocará o widget recém-configurado na tela inicial.
Aqui está o meu arquivo config_activity.xml completo:
Crie a atividade de configuração
Agora, precisamos criar nossa atividade de configuração.
Para começar, crie uma nova classe Java denominada ConfigActivity. Nesta atividade, recuperaremos o ID do widget de aplicativo a partir da intenção que lançou a atividade de configuração. Se essa intenção não tiver um ID de widget, precisaremos chamar o método finish ():
Intenção intenção = getIntent (); Extras do pacote configurável = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
Em seguida, precisamos criar uma intenção de retorno, passar o appWidgetId original e definir os resultados da configuração Atividade:
Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); terminar(); }}}
Se você fornecer uma atividade de configuração, a transmissão ACTION_APPWIDGET_UPDATE não será enviada automaticamente quando a atividade de configuração for iniciada, o que significa o método onUpdate () não vai ser chamado quando o usuário criar uma instância do seu widget.
Para garantir que seu widget seja criado com informações e conteúdo atualizados, sua configuração devo acionar a primeira solicitação onUpdate ().
Aqui está o ConfigActivity completo:
importar android.app.Activity; importar android.appwidget.AppWidgetManager; importar android.os.Bundle; importar android.widget.Button; importar android.content.Intent; importar android.view.View; importar android.view.View.OnClickListener; importar android.widget.Toast; classe pública ConfigActivity estende Activity {@Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.config_activity); setResult (RESULT_CANCELED); Button setupWidget = (Botão) findViewById (R.id.setupWidget); setupWidget.setOnClickListener (new OnClickListener () {@Override public void onClick (View v) {handleSetupWidget ();}}); Button configButton = (Botão) findViewById (R.id.configButton); configButton.setOnClickListener (new OnClickListener () {@Override public void onClick (View v) {handleConfigWidget ();}}); } private void handleSetupWidget () {showAppWidget (); } private void handleConfigWidget () {Toast.makeText (ConfigActivity.this, "Opções de configuração", Toast.LENGTH_LONG) .show (); } int appWidgetId; showAppWidget () vazio privado {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Intenção intenção = getIntent (); Extras do pacote configurável = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // A FAZER: Execute a configuração // Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); terminar(); }}}
Depois de criar uma atividade de configuração, você deve declarar essa atividade no manifesto e especificar que ela aceita a ação APPWIDGET_CONFIGURE:
Por fim, como uma atividade de configuração é referenciada fora do escopo do pacote, precisamos declarar essa atividade em nosso AppWidgetProviderInfo, que nesta instância é o arquivo collection_widget_info.xml:
android: configure = "com.jessicathornsby.collectionwidget.ConfigActivity">
Testando seu projeto
Agora é hora de testar seu projeto finalizado:
- Instale seu projeto atualizado em um dispositivo Android físico ou no AVD.
- Exclua todas as instâncias anteriores do seu widget para garantir que você esteja trabalhando com a versão mais recente.
- Pressione e segure qualquer área vazia da tela inicial e selecione Widgets quando solicitado.
- Encontre seu widget no Seletor de widgets e pressione e segure para selecioná-lo.
- Solte o widget na tela inicial. A atividade de configuração deve iniciar automaticamente.
- Dê um clique no botão Executar algumas configurações e um brinde às opções de configuração deve aparecer, confirmando que essa interação foi registrada com êxito.
- Imagine que você ajustou as configurações do widget e agora está pronto para colocá-lo na tela inicial. toque no botão Criar O Widget e esse widget deverá ser criado com sucesso.
Você pode baixar o projeto completo do widget de coleção no GitHub.
Empacotando
Neste artigo, criamos um widget de coleção rolável que exibe um conjunto de dados na tela inicial do usuário.
Se você quiser continuar trabalhando com este projeto, tente adicionar seu próprio código ao método onUpdate () para criar um widget que seja atualizado com novas informações no intervalo definido no seu arquivo AppWidgetProviderInfo (collection_widget_info).
Se você criar um widget Android, compartilhe suas criações nos comentários abaixo!
