Você está aqui: Android Java ::: android.widget ::: Button

Como detectar um clique em um botão do Android usando setOnClickListener() e exibir uma mensagem AlertDialog

Quantidade de visualizações: 1568 vezes
O método setOnClickListener() nos permite definir a ação que será disparada ao clicarmos em um botão. Note que primeiro nós localizamos o botão no arquivo XML de layout usando o método findViewById() da classe View.

Comece analisando o arquivo XML de layout no qual criamos um botão e o colocamos como filho de um elemento LinearLayout:

----------------------------------------------------------------------
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"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
  tools:context=".MainActivity">

  <Button xmlns:android="
    http://schemas.android.com/apk/res/android"
    android:id="@+id/btn_enviar"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/btn_enviar"
    android:textAllCaps="false"
    />
</LinearLayout>

E agora o código Java no arquivo MainActivity.java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package com.example.estudosandroid;

import androidx.appcompat.app.AppCompatActivity;

import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // vamos detectar um clique no botão e exibir uma mensagem AlertDialog
    Button button = (Button) findViewById(R.id.btn_enviar);
    button.setOnClickListener(new View.OnClickListener(){
      public void onClick(View view) {
        AlertDialog dialogo = new
          AlertDialog.Builder(MainActivity.this).create();
        dialogo.setTitle("Aviso");
        dialogo.setMessage("Esta é uma mensagem de aviso");
        dialogo.setButton(AlertDialog.BUTTON_NEUTRAL, "OK",
          new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which){
              dialog.dismiss(); // fecha o AlertDialog
            }
          }
        );
        dialogo.show();
      }
    });
  }
}


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 Android

Quantidade de visualizações: 2144 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 ::: androidx.appcompat.app ::: AppCompatActivity

Como usar o método startActivity() da classe Activity ou AppCompatActivity do Android para mudar de telas

Quantidade de visualizações: 1738 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.


Android Java ::: Gerenciadores de Layout ::: LinearLayout

Como usar o gerenciador de layout LinearLayout em suas aplicações Android

Quantidade de visualizações: 7894 vezes
O gerenciador de layout LinearLayout (no pacote android.widget) do Android SDK nos permite exibir seus componentes filhos em uma única coluna ou linha. Esta classe está disponível desde a API Level 1. Veja sua posição na hierarquia de classes do Android:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

java.lang.Object 
   android.view.View 
      android.view.ViewGroup 
         android.widget.LinearLayout 

As classes diretas mais conhecidas são: NumberPicker, RadioGroup, SearchView, TabWidget, TableLayout, TableRow e ZoomControls.

Veja um exemplo de como podemos usar o gerenciador LinearLayout em um arquivo de layout em XML:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
</LinearLayout>

Veja agora como este mesmo gerenciador pode ser criado em tempo de execução a partir do método onCreate() de uma activity:

----------------------------------------------------------------------
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.ViewGroup.LayoutParams;
import android.widget.LinearLayout;

public class EstudosActivity extends Activity
{
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        // vamos criar o gerenciador de layout
        LinearLayout layout = new LinearLayout(this);
        layout.setOrientation(LinearLayout.VERTICAL);
        layout.setLayoutParams(new LinearLayout.LayoutParams(
           LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));

        // vamos atribuir este layout à janela
        setContentView(layout);
    }
}

Em ambos os exemplos, os componentes filhos serão dispostos em uma única coluna, ou seja, serão empilhados na vertical, uma vez que o valor da orientação do layout é vertical. Note que a orientação do layout LinearLayout é definida em um arquivo XML usando o atributo android:orientation. Via código, a orientação é definida por meio de uma chamada ao método setOrientation(). A orientação padrão de um LinearLayout é horizontal (os componentes são dispostos em uma linha horizontal e a quebra de linha só ocorrerá quando forçada por questões de espaço).


Vamos testar seus conhecimentos em Topografia

Rumo e Azimute

Concurso Analista Ambiental - Engenheiro Agrimensor.

Observe a figura abaixo e assinale a alternativa correta.



A) Rumo de A2: N59ºE e Azimute de A1: 59º

B) Rumo de A2: S37ºW e Azimute de A2: 217º

C) Rumo de A1: N23ºE e Azimute de A2: 337º

D) Rumo de A3: S48ºE e Azimute de A1: 37º

E) Rumo de A2: N37ºE e Azimute de A1: 132º
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

Água Fria: Reservatórios

Sobre o projeto de reservatórios de água fria, assinale a alternativa correta:

A) O volume mínimo do reservatório para uso doméstico, salvo o volume do combate a incêndio, deve ser, no mínimo, o necessário para 3 dias de consumo.

B) O reservatório de água potável não deve ser enterrado em hipótese alguma, devido à possibilidade de contaminação proveniente do solo.

C) No caso de residência de pequeno porte, é recomendado que a reserva mínima seja de 1000 L.

D) Reservatórios de maior capacidade devem ser divididos em dois ou mais compartimentos para permitir operações de manutenção sem haver interrupção na distribuição de água.

E) A extremidade da tomada d'água no reservatório (saída para o barrilete de distribuição) deve estar no mesmo nível do fundo desse reservatório.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

Sistema domiciliar de abastecimento de água

Há diversas opções de materiais empregados nas instalações de água fria. Cada tipo de material se enquadra às condições em que será utilizado. Nas instalações residenciais do Brasil, o material mais empregado é o PVC, por apresentar diversas vantagens.

Quais das opções a seguir apresentam as principais características desse tipo de material?

I. Leve (1,4g/cm3), o que facilita seu manuseio e aplicação.

II. Por ser tóxico, apresenta risco à saúde humana.

III. Sólido e resistente a choques.

IV. Durável: sua vida útil em construções é superior a 50 anos.

As afirmações corretas são:

A) I e II, apenas.

B) I, III e IV, apenas.

C) I, II e III, apenas.

D) II e III, apenas.

E) I, II, III e IV.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Hidrologia

Como é chamada a área de relevo mais elevado entre cursos de água contíguos e que serve para delimitação das bacias hidrográficas?

A) Vale fluvial.

B) Colúvio.

C) Interflúvio.

D) Planalto.

E) Planície pluvial.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Fundações

Fundações profundas

A grande vantagem das estacas moldadas in solo em relação às pré-moldadas é permitir que o comprimento estritamente necessário seja concretado.

O tipo de fundação profunda constituída por concreto, moldada in loco e executada por meio de trado contínuo e injeção de concreto pela própria haste do trado, é a:

A) estaca escavada mecanicamente.

B) estaca injetada.

C) estaca hélice contínua.

D) estaca Franki.

E) estaca-raiz.
Verificar Resposta Estudar Cards Todas as Questões

Veja mais Dicas e truques de Android Java

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga 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 funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha 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
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 58 usuários muito felizes estudando em nosso site.