 |
|
Você está aqui: Android Java ::: Dicas & Truques ::: AndroidManifest.xml |
|
Atributos do elemento <application> e seus possíveis valores (AndroidManifest.xml)Quantidade de visualizações: 6651 vezes |
|
|
O elemento <application> representa os atributos globais de uma aplicação. Este elemento contém sub-elementos que declaram cada um dos componentes da aplicação e apresenta atributos que afetam todos eles. O elemento <application> está contido no elemento <manifest> e pode conter os elementos <activity>, <activity-alias>, <service>, <receiver>, <provider> e <uses-library>. Veja a lista completa dos atributos do elemento <application>:
Veja agora uma descrição resumida de cada um destes atributos (em outras dicas desta seção você encontra estes atributos individualmente): android:allowTaskReparenting - Indica se as atividades que a aplicação define podem ser movidas da tarefa que as iniciou para a tarefa com as quais elas possuem afinidade quando tal tarefa é a próxima a ser o foco principal da aplicação. Se o valor for "true" elas poderão ser movidas e "false" se eles devem permanecer com a tarefa que as iniciou. O valor padrão é "false". O elemento <activity> possui seu próprio atributo allowTaskReparenting que pode sobrescrever o valor definido no elemento <application>. android:backupAgent - O nome da classe que que implementa o agente de back-up da aplicação, uma sub-classe de BackupAgent. O valor deste atributo deve ser um nome de classe completamente qualificado (tal como "net.arquivodecodigos.projeto.MeuBackupAgent"). Contudo, como um atalho, se o primeiro caractere do nome for um ponto (por exemplo, ".MeuBackupAgent"), este será precedido pelo nome de pacote especificado no elemento <manifest>. Não há valor padrão para este atributo. android:debuggable - Indica se a aplicação pode ser depurada (debugged), mesmo quando esta estiver sendo executada em um dispositivo em modo usuário. Se o valor for "true", a depuração poderá ser feita. O valor padrão é "false". android:description - Um texto mais longo e mais descritivo sobre a aplicação. Este texto é entendido por humanos e deve ser definido como uma referência a um recurso do tipo string. android:enabled - Indica se o sistema Android pode instanciar componentes da aplicação. Se o valor for "true", isso poderá ocorrer. Também, se o valor for "true", o atributo enabled de cada componente definirá se este estará habilitado ou não. Se o valor for "false", ele sobrescreve os valores enabled de cada componente. O valor padrão é true. android:hasCode - Indica se a aplicação contém algum código. Se o valor for "true", ela contém códigos. Quando o valor é "false", o sistema não tenta carregar o código da aplicação ao lançar componentes. O valor padrão é "true". Uma aplicação não possui códigos próprios apenas quando está usando classes de componentes, tal como uma atividade que usa uma classe AliasActivity, o que é uma situação muito rara. android:hardwareAccelerated - Indica se a renderização fornecida por aceleração de hardware deve ser habilitada para todas as Activities e Views da aplicação. Se o valor for "true", a renderização estará habilitada. O valor padrão é "false". A partir do Android 3.0, um renderizador OpenGL por acelerador de hardware está disponível às aplicações, de forma a melhorar a performance de muitas operações de gráficos 2D comuns. Quando o renderizador por aceleração de hardware está habilitado, a maioria das aplicações no Canvas, Paint, Xfermode, ColorFilter, Shader e Camera são aceleradas. Isso resulta em animações mais suaves, rolagem mais suve e respostas mais precisas, atém mesmo para aplicações que não usam as bibliotecas OpenGL do framework de forma explícita. É importante observar que nem todas as operações OpenGL 2D são aceleradas. Se você habilitar a a renderização fornecida por aceleração de hardware, teste sua aplicações para se certificar que esta pode fazer uso do renderizador sem provocar erros ou falhas. android:icon - Um ícone para a aplicação como um todo, e ícone padrão para os componentes da aplicação. Este atributo deve ser definido como uma referência a um recurso drawable contendo uma imagem (por exemplo, "@drawable/icon". Não há ícone padrão. android:killAfterRestore - Indica se a aplicação deve ser finalizada depois de suas configurações terem sido restauradas durante uma operação de restauração completa do sistema. Operações de restauração de pacotes únicos nunca farão com que a aplicação seja fechada. A operação de restauração completa do sistema geralmente ocorre apenas um vez, quando o telefone é configurado pela primeira vez. Aplicações de terceiros normalmente não precisam usar este atributo. O valor padrão é true, o que significa que, depois que a aplicação finalizar o processamento de seus dados depois de uma restauração do sistema, ela será fechada. android:label - Um rótulo entendido por humanos para a aplicação como um todo, e o rótulo padrão para cada um dos componentes da aplicação. O rótulo deve ser definido como uma referência para um recurso de string, de forma que ele possa ser localizado, assim como as outras strings na interface de usuário. Contudo, como uma conveniência, enquanto estivermos desenvolvendo a aplicação, seu valor pode ser definido como um literal string. android:logo - Um logotipo para a aplicação como um todo, e o logo padrão para as activities. Este atributo deve ser definido como uma referência a um recurso drawable contendo uma imagem (por exemplo, "@drawable/logo". Não há logotipo padrão. android:manageSpaceActivity - O nome completo e qualificado de uma sub-classe de Activity que o sistema pode lançar para permitir aos usuários gerenciar a memória ocupada pela aplicação no dispositivo. A activity deve também ser declarada com o elemento <activity>. android:name - O nome completo e qualificado de uma sub-classe de Application implementada para a aplicação. Quando o processo da aplicação é iniciado, um objeto desta classe é instanciado antes dos demais componentes. Esta sub-classe é opcional; a maioria das aplicações não precisa de uma. Na ausência da sub-classe, o Android usa uma instância da classe base Application. android:permission - O nome de uma permissão que os clientes devem ter a fim de interagir com a aplicação. Este atributo é uma forma conveniente de definir uma permissão que se aplica a todos os componentes da aplicação. O valor definido pode ser sobrescrito por aqueles definidos nos componentes individuais. android:persistent - Indica se a aplicação deve permanecer executando o tempo todo. Se o valor for "true" isso ocorrerá. O valor padrão é "false". As aplicações normalmente não devem definir valor para este atributo. Ele é direcionado apenas a algumas aplicações de sistema. android:process - O nome de um processo no qual todos os componentes da aplicação serão executados. Cada componente pode sobrescrever este atributo e definir o seu próprio. Por padrão, o Android cria o processo para a aplicação quando o primeiro de seus componentes precisa ser executado. A partir daí todos os demais componentes executam neste mesmo processo. O nome do processo padrão deve ser igual ao nome de pacote definido no elemento <manifest>. Ao atribuir a este atributo o nome de um processo que é compartilhado com outra aplicação, devemos cuidar para que os componentes de ambas aplicações executem no mesmo processo. Mas, somente se as duas aplicações também compartilharem o ID de usuário e serem assinadas com o mesmo certificado. Se o nome atribuído a este atributo começar com dois pontos (":"), um novo processo, privado em termos da aplicação, será criado quando houver a necessidade. Se o nome do processo começar com uma letra minúscula, um processo global com este nome será criado. Um processo global pode ser compartilhado com outras aplicações, reduzindo o uso de recursos. android:restoreAnyVersion - Indica se a aplicação está preparada para tentar restaurar quais conjuntos de dados em back-up, até mesmo se o back-up foi feito por uma versão mais atual da aplicação que está instalada no dispositivo. Se definirmos o valor true para este atributo, o Backup Manager tentará a restauração até mesmo quando uma diferença de versão sugerir que os dados são incompatíveis. Use este atributo com cuidado. O valor padrão é false. android:taskAffinity - Um nome de afinidade que se aplica a todas as atividades dentro da aplicação, exceto aquelas que definiram uma afinidade diferente em seus atributos taskAffinity. Por padrão, todas as atividades dentro da mesma aplicação compartilham a mesma afinidade. O nome desta afinidade é o mesmo definido para o nome de pacote no elemento <manifest>. android:theme - Uma referência a um recurso de estilo definindo um tema padrão para todas as activities na aplicação. As activities individuais podem sobrescrever o padrão fornecendo seus atributos de temas próprios. android:uiOptions - Permite definir opções extras para a UI (User Interface) das atividades. Os valores possíveis são "none" e "splitActionBarWhenNarrow". |
|
 Link para compartilhar na Internet ou com seus amigos: |
|
Android Java ::: android.widget ::: Spinner |
Entenda e aprenda a usar a classe Spinner em suas aplicações AndroidQuantidade de visualizações: 2153 vezes |
|
Um objeto da classe Spinner no Android representa uma lista de itens, ou uma caixa de combinação, a partir da qual o usuário poderá escolher apenas uma opção. Em outras linguagens de programação tais como Delphi e C#, este controle é chamado de ComboBox. No Swing do Java, ele é chamado JComboBox. No HTML, nós o conhecemos como <select>. Veja a posição da classe Spinner na hieraquia de classes do Android: public class Spinner extends AbsSpinner implements DialogInterface.OnClickListener java.lang.Object android.view.View -> android.view.ViewGroup -> android.widget.AdapterView<android.widget.SpinnerAdapter> -> android.widget.AbsSpinner -> android.widget.Spinner Veja a seguir como podemos declarar um elemento Spinner no arquivo XML de layout: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- Spinner android:id="@+id/cidade" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="10dp" android:layout_gravity="center" android:layout_margin="10dp" android:entries="@array/cidades_nomes" /> Note que o elemento Spinner que declaramos possui o id "cidade" e, a parte mais importante, o vetor "cidades_nomes" para o seu atributo entries. Este vetor foi declarado no arquivo strings.xml da seguinte forma: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- <string-array name="cidades_nomes"> <item>Goiânia</item> <item>Cuiabá</item> <item>São Paulo</item> <item>Rio de Janeiro</item> <item>Curitiba</item> </string-array> Pronto. Isso é tudo. Se você executar seu aplicativo agora, já verá um caixa de combinação, ou seja, um Spinner com os nomes de cinco cidades ser exibido na tela. Experimente selecionar um dos itens. Em mais dicas dessa seção você verá como obter o item selecionado, como disparar uma ação como resultado da mudança de seleção de itens, como adicionar itens ao Spinner em tempo de execução e muito mais. |
Android Java ::: android.widget ::: Toast |
Como usar a classe Toast em suas aplicações AndroidQuantidade de visualizações: 9923 vezes |
|
Um objeto da classe pública Toast (do pacote android.widget) nos oferece uma forma de exibir uma pequena e rápida mensagem aos usuários de nossas aplicações Android. A mensagem exibida aparecerá como uma view flutuante sobre a tela atual da aplicação e não receberá foco. O objetivo é alertar o usuário sobre o sucesso ou fracasso de alguma atividade, aguardar alguns segundos e fazer a mensagem desaparecer. Veja a posição desta classe na hierarquia de classes do Android SDK: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- java.lang.Object android.widget.Toast Eis um exemplo de como usar um objeto desta classe para exibir uma breve mensagem quando o usuário clicar um botão na view: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
package arquivo.estudos;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
public class EstudosActivity extends Activity
{
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Button button = (Button) findViewById(R.id.btn);
button.setOnClickListener(new View.OnClickListener(){
public void onClick(View v) {
Toast.makeText(EstudosActivity.this,
"Bem-vindo à minha aplicação Android",
Toast.LENGTH_SHORT).show();
}
});
}
}
O botão usado neste exemplo foi criado em um layout XML com a seguinte declaração: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<Button
android:id="@+id/btn"
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:text="Clique" />
Veja que aqui nós usamos o método estático makeText() da classe Toast para exibir a mensagem ao usuário. A constante Toast.LENGTH_SHORT faz com que a mensagem seja exibida por um curto período de tempo. |
Android Java ::: androidx.appcompat.app ::: AppCompatActivity |
Como usar o método startActivity() da classe Activity ou AppCompatActivity do Android para mudar de telasQuantidade de visualizações: 1767 vezes |
|
Por mais simples que nossas aplicações Android sejam, elas serão compostas de duas ou mais telas, ou seja, duas ou mais Activity ou AppCompatActivity. Nesta dica mostrarei como usar o método startActivity() dessas duas classes para levar o usuário da primeira tela para a segunda. Lembre-se de que AppCompatActivity herda de Activity e, nos dias atuais, é a classe preferida para representar as telas individuais das aplicações Android. Comece criando um novo projeto no Android Studio. Escolha Empty Activity e dê o nome "App Duas Telas" ao projeto. Observe que o Android Studio já criou uma Activity ou AppCompatActivity com o nome MainActivity.java. Vamos nos certificar de que esta Activity é de fato a tela principal da aplicação. Abra o arquivo AndroidManifest.xml e veja se seu elemento <activity> se parece com o que temos abaixo: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
Se tudo estiver Ok, vamos agora criar a segunda tela. Clique com o botão direito em cima do pacote "com.example.appduastelas" e escolha New -> Activity -> Empty Activity. Dê o nome "SegundaTela", desmarque a opção Launcher Activity e clique o botão Finish. Se você observar o arquivo AndroidManifest.xml novamente, você verá que a segunda tela já foi adicionada lá. Agora vamos examinar o arquivo XML de layout para a primeira tela (layout\activity_main.xml): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="16dp"
android:orientation="vertical"
tools:context="com.example.appduastelas.MainActivity">
<Button
android:id="@+id/abrir_tela"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="20dp"
android:onClick="abrirSegundaTela"
android:text="@string/abrir_tela" />
</LinearLayout>
Note que temos um elemento <LinearLayout> e, dentro dele, um elemento <Button>. No botão nós declaramos o método abrirSegundaTela para seu atributo onClick. Não esqueça de atualizar o arquivo strings.xml para refletir o texto do botão "@string/abrir_tela". Pronto. Agora vamos ver o arquivo XML de layout para a segunda tela (layout\activity_segunda_tela.xml): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="16dp"
android:orientation="vertical"
tools:context="com.example.appduastelas.SegundaTela">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Sou a segunda tela."/>
</LinearLayout>
Nesse layout nós temos um elemento <LinearLayout> e, dentro dele, um elemento <TextView>, que serve apenas para exibir um texto qualquer na segunda tela. Para finalizar, só precisamos escrever o método abrirSegundaTela() na MainActivity.java. Veja o código completo: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
package com.example.appduastelas;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
// método usado para abrir a segunda tela
public void abrirSegundaTela(View view) {
Intent intent = new Intent(this, SegundaTela.class);
startActivity(intent);
}
}
Veja que dentro do método abrirSegundaTela(), que recebe uma View com parâmetro, nós criamos um novo objeto da classe Intent e fornecemos o nome da segunda tela. Em seguida fazemos uma chamada ao método startActivity() passando o Intent recém-criado como argumento. Pronto! É só isso. Execute a aplicação, clique no botão e veja a segunda tela ser exibida. Pressione o botão Voltar e repita quantas vezes quiser. Agora é só criar mais telas e desenvolver vários e vários apps Android. |
Veja mais Dicas e truques de Android Java |
Dicas e truques de outras linguagens |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
 Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesTenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais |
Linguagens Mais Populares |
|
1º lugar: Java |
