Uma ‘atividade’ é uma coisa única e focada que o usuário pode fazer, de acordo com a documentação oficial dos andróides.

O termo claramente deriva do verbo "agir", que basicamente significa realizar uma ação ou interagir com algo.

Mesmo que possamos ter uma atividade sem componentes visuais, a maioria das atividades é criada para hospedar vistas e widgets com os quais os usuários podem interagir.

Portanto, as atividades podem se referir vagamente a toda a tela com a qual o usuário irá interagir.

Tutorial DIY - Artesanato Pagão - Móbile de Pedras e Cristais

Tutorial DIY - Artesanato Pagão - ...
Tutorial DIY - Artesanato Pagão - Móbile de Pedras e Cristais

Com esta forma de pensar aqui estão algumas das coisas que podemos fazer com nossa atividade:

Não. Ação Descrição
1. Abrir nova atividade Isto então substitui a atual atividade ou tela.
2. Feche a atual atividade para que ela não seja mais visível para nós. O sistema Android não vai matá-lo completamente, basta colocá-lo em segundo plano, para não voltar a ele novamente.
3. Gire o dispositivo Digamos que você esteja assistindo um vídeo ou jogando um jogo a partir deste aplicativo e queira vê-lo em layout diferente. Este processo provoca a recriação da atividade de modo a atender às suas necessidades de layout.

Fazer coisas como o sistema andróide acima faz com que o sistema andróide aumente vários ciclos de vida. Estes são basicamente métodos que são levantados de forma orientada a eventos em vários estágios do ciclo de vida de uma `atividade’. Por exemplo, criação, pausa, reinício, partida, reinício, parada, etc.

Mecanismos de apresentação de uma atividade.

As "atividades" podem ser apresentadas de várias maneiras em andróide:

Não. Mecanismo Descrição
1. Janela de tela cheia : A forma mais comum de apresentar uma atividade. Com isto, eles cobrem a tela inteira.
2. Janelas Flutuantes : Atividades podem ser definidas como janelas flutuantes através de um tema com o conjunto de atributos `windowIsFloating’.
3. **Embedding*** : Atividades também podem ser incorporadas dentro de outra atividade utilizando ActivityGroup.

Entretanto, observe que a incorporação não é mais atraente, já que o ActivityGroup foi depreciado com a introdução de "Fragmentos", muito atrás no "Nível 13 do ICA". Os fragmentos são basicamente sub-atividades, com seu próprio ciclo de vida.

Atividade classe Definição

Vejamos também uma descrição programática de uma atividade.

Primeiro ela pertence ao pacote "android.app":

package android.app;

A "atividade" é uma classe como qualquer outra classe, mas também única à sua maneira. Ela também é pública, portanto é visível e utilizável dentro de outros pacotes fora de sua própria embalagem.

public class Activity..{}

Ser uma classe faz com que ela também tenha características Object Oriented que outras classes têm gostado:

  1. Habilidade de derivar de outras classes e ser derivada de.
  2. Habilidade de implementar interfaces.
  3. Habilidade de ter seus próprios métodos, campos e classes internas.

De fato, a classe Atividade deriva da classe ContextThemeWrapper.

public class Activity extends ContextThemeWrapper..{}

O `Context ThemeWrapper’ dá à classe a capacidade de manipular e modificar o tema a partir do que está no contexto embrulhado.

Além disso, uma Atividade implementa várias interfaces:

public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2 Window.Callback KeyEvent.Callback View.OnCreateContextMenuListener ComponentCallbacks2{}
Crianças e netos da atividade

São as subclasses de atividade direta e indireta.

Aqui estão as subclasses diretas:

Não. Descrição Atividade Descrição
1. FragmentActivity A super classe usada por atividades que desejam Fragmentos e APIs de carregadores usando a biblioteca de suporte
2. NativeActivity Para aqueles que querem que uma atividade conveniente seja implementada puramente em código nativo.
3. ListActivity Uma atividade especializada em exibir uma lista de itens vinculados a uma fonte de dados.
4. ExpandableListActivity Uma atividade especializada em exibir lista expansível de itens vinculados a uma fonte de dados.
5. AliasActivity Fornece um mecanismo semelhante a um mecanismo para uma atividade. Faz isto lançando outra atividade e depois se matando.
6. AccountAuthenticatorActivity Super classe para criar atividades que implementem o AbstractAccountAuthenticator.
7. ~ActivityGroup~ Deprecated back in the API 13 após a introdução de Fragmentos. Antes disso, era a forma de criar uma tela com múltiplas atividades embutidas.

Bem, essas são as crianças da atividade.

Vejamos agora as subclasses netos/indirectos.

Não. Atividade Pais Principais Descrição
1. AppCompatActivity FragmentActivity AppCompatActivity é a super classe para o planejamento de atividades para utilizar recursos de barra de ação.
2. ~**ActionBarActivity*** AppCompatActivity Deprecated. Antes disso, era usado para fornecer recursos de barra de ação às atividades. Agora esse papel foi para AppCompatActivity.
3. ~TabActividade~ ActivityGroup Deprecated way back in the API level 13. Antes disso, era usado para criar atividades em forma de abas, agora os fragmentos podem fazer isso.
4. PreferenceActivity ListActivity A super classe a ser usada para aqueles que pretendem mostrar uma hierarquia de preferências aos usuários.
5. LauncherActivity ListActivity Isto mostrará uma lista de todas as atividades que podem ser realizadas para uma determinada intenção.

Capacidades A classe de atividade proporciona a seus filhos

Podemos, e temos dito, que as atividades representam uma única coisa focada que um usuário pode fazer.

Portanto, sabemos que nos permite usar e renderizar visualizações e widgets com os quais os usuários podem interagir.

Entretanto, vamos agora explorar mais detalhes e funcionalidades específicas de um nível inferior que a classe `Atividade’ dá às suas crianças.

1. Capacidades de contexto
  1. Verificação de várias permissões : Por exemplo: a checkUriPermission(String permission, int pid, int uid) determinará se um determinado processo e ID de usuário em execução no sistema tem a permissão aprovada, checkUriPermission(Uri uri, int pid, int uid, int modeFlags) determinará se um determinado processo e ID de usuário em execução no sistema tem a permissão de acesso ao Uri aprovado, etc.
  2. Conectar ou criar serviço de aplicação : Isto pode ser feito através do método "bindService(Intent service, ServiceConnection conn, int flags)".
    3.Criar outros Contextos : Por exemplo createConfigurationContext(Configuration overrideConfiguration) irá criar um novo objeto Contexto para o contexto atual, mas com recursos ajustados à configuração passada,createPackageContext(String packageName, int flags) retorna um novo objeto Contexto para o nome da aplicação dada.
  3. Lista de Bancos de Dados e Arquivos Associados : databaseList() irá nos fornecer um array de strings com os bancos de dados privados associados a este pacote de aplicação Context enquanto que fileList()` retorna um array de strings com os arquivos privados associados a este pacote de aplicação Context.
  4. **Delete Associated Database and File* : Context nos fornece métodos: deleteDatabase(String name) para excluir o SQLiteDatabase associado ao pacote de aplicação deste Contexto e deleteFile(String name) para excluir o dado arquivo privado associado ao pacote de aplicação deste Contexto.
    6.
    Contextualização da aplicação : Context’s getApplicationContext() nos devolverá o único objeto de aplicação global do processo atual.
    7.
    Obtendo informações da aplicação** : Através do getApplicationInfo() podemos obter as informações completas da aplicação do pacote atual do Contexto.

Exemplos rápidos de atividades

1. Como iniciar uma `Atividade’.

Para iniciar uma "atividade" você precisa de um objeto "interno". Vamos criar um método que possa iniciar para nós uma atividade. Este método tomará um objeto de contexto assim como o nome da classe para a "atividade" alvo, ou seja, a "atividade" que queremos abrir.

    void start(Context c, Class e){
        Intent i = new Intent(,e);
        c.startActivity(i);
        //a.finish();
    }
2. Como Acabar/Desactivar uma "Actividade".

Para terminar uma atividade utilizamos o método finish().

    void killIntent(Context c){
        Intent i = new Intent(c,MainActivity.class);
        c.startActivity(i);
        c.finish();
    }
3. Como determinar se uma atividade está em primeiro plano

Este método de exemplo pode determinar para nós se uma atividade está em primeiro plano ou não. Ele retorna um valor booleano com base no resultado.

    public static boolean isForeground(Context context, String className) {
        if (context == null || TextUtils.isEmpty(className)) {
            returnfalse;
        }
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> list = am.getRunningTasks(1);
        if (list != null && list.size() > 0) {
            ComponentName cpn = list.get(0).topActivity;
            if (className.equals(cpn.getClassName())) {
                return true;
            }
        }
        returnfalse;
    }

    public static boolean isForeground(Activity activity) {
        return isForeground(activity, activity.getClass().getName());
    }
4. como lidar com a contra-impressão

Digamos que você quer lidar corretamente com a pressão traseira, pois talvez queira mostrar ao usuário um diálogo de alerta antes de apenas sair da atividade atual. Nesse caso, você cria um método ‘handleBackPress()handleBackPress().

    public void handleBackPress() {
        mExitDialog = true;
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style
                .AlertDialogStyle);
        builder.setTitle(R.string.leave_chat)
                .setMessage(R.string.leave_chat_desc)
                .setCancelable(false)
                .setNegativeButton(R.string.cancel,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                mExitDialog = false;
                                dialog.cancel();
                            }
                        })
                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        //showSaveHistoryDialog();
                    }
                });
        AlertDialog alert = builder.create();
        alert.show();
        alert.getWindow().setBackgroundDrawable(new ColorDrawable(getResources().getColor(R.color
                .black14)));
    }

No caso acima, estamos mostrando um diálogo de alerta ao usuário quando ele clica no botão voltar.

Android AppCompatActivity

A `AppCompatActivity’ é uma classe que atua como a super classe para atividades que querem aproveitar as características da barra de ação da biblioteca de apoio.

A exigência de utilizar a android.support.v7.app.ActionBar dentro de sua atividade é:

  1. Estar executando o API nível 7 ou superior.
  2. Em seguida, estenda esta classe.
  3. Definir seu tema de atividade para android.support.v7.appcompat.R.style#Theme_AppCompat Theme.AppCompat ou tema similar.

Os temas são definidos no AndroidManifest.xml, por exemplo

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

A AppCompatActivity' é definida dentro do pacote android.support.v7.app’:

package android.support.v7.app;

Ela deriva de android.support.v4.app.FragmentActivity:

public class AppCompatActivity extends FragmentActivity{}

E implementa várias interfaces:

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {}

Aqui está um exemplo de uma classe derivada da AppCompatActivity:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Definição do tema `AppCompatActivity’.

Atividade de Patentes, como outros temas de atividade, pode ser definida via androidmanifest.

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

ou programática através do método setTheme():

public void setTheme(@StyleRes final int resid) {}

Podemos criar um tema de material personalizado para ser usado pela AppCompatActivity:

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

</resources>

Então também podemos definir esse tema globalmente para toda a aplicação desta forma, utilizando o atributo android:theme="...":

<application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_roundIcon="@mipmap/ic_launcher_round"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity android_name=".MainActivity">

        </activity>
    </application>

Recuperando AppCompatActivity ActionBar

A `AppCompatActivity’ nos dá um método para recuperar uma referência a sua barra de ação:

public ActionBar getSupportActionBar(){}

Se não tiver um, então ‘nulo’ é devolvido.

Usando ToolBar como barra de ação em AppCompatActivity

Podemos utilizar android.support.v7.widget.Toolbar em vez de uma barra de ação. As barras de ferramentas têm a vantagem de flexibilidade na utilização e personalizações.

As barras de ação normalmente fazem parte da decoração opaca da janela da ActionBars. Portanto, elas são controladas pela estrutura.

As barras de ferramentas, por outro lado, podem ser usadas dentro do layout da sua aplicação. Portanto, elas são flexíveis.

Digamos que temos uma barra de ferramentas definida como segue:

...
<android.support.v7.widget.Toolbar
            android_id="@+id/toolbar"
            android_layout_width="match_parent"
            android_layout_height="?attr/actionBarSize"
            android_background="?attr/colorPrimary"
            app_popupTheme="@style/AppTheme.PopupOverlay" />
...

dentro de nossa atividade_main.xml.

Podemos utilizá-la como barra de ação utilizando a setSupportActionBar() onde passamos a referência toolbar como parâmetro.

public void setSupportActionBar(@Nullable Toolbar toolbar) {}

Exemplo:

Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);

Para liberá-lo você passa ‘nulo’.

Android Studio – Projeto Criando Atividades Vazias

Como criar uma atividade vazia no Estúdio Android

Como criar um projeto em estúdio andróide com modelo de Atividade Vazia. Vemos como usar o estúdio Android para criar uma atividade vazia.

Atividade Vazia é apenas um modelo para desenvolvimento de andróides. É o modelo mais fácil de começar, pois gera para nós um único arquivo java e um único arquivo de layout xml.

Aqui está o processo.

  1. Primeiro crie um projeto vazio no estúdio androide. Vá para File –> New Project.
  2. Digite o nome do aplicativo e escolha o nome da empresa.
  3. Escolha o SDK mínimo.
  4. Escolher atividade vazia.
  5. Clique em Finish.

Isto irá gerar para nós um projeto com o seguinte:

Não. Nome Tipo Descrição
1. activity_main.xml XML Layout Será inflado no MainActivity View. Você adiciona suas visões e widgets aqui.
2. MainActivity.java Class Your Launcher activity

A atividade será automaticamente registrada no android_manifest.xml. As atividades Android são componentes e normalmente precisam ser registradas como um componente de aplicação.
Se você criou a sua manualmente, então registre-a dentro da <aplicação>...<aplicação> como a seguir, substituindo a MainActivity pelo nome de sua atividade:

        <activity android_name=".MainActivity">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />
                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Você pode ver que uma ação e categoria são especificadas como filtros de intenção. A categoria faz nossa MainActivity como atividade lançadora. As atividades do lançador são executadas primeiro quando o aplicativo andróide é executado.

Android Studio – Criando Projeto de Atividade Básica

Como criar um projeto em estúdio andróide com modelo de atividade básica.

Este é um tutorial para iniciantes verem como criar um projeto androide com base no modelo básico.

Aqui está o processo:

  1. Primeiro crie um novo projeto no estúdio androide. Vá para Arquivo –> Novo Projeto.
  2. Digite o nome do aplicativo e escolha o nome da empresa.
  3. Escolha o SDK mínimo.
  4. Escolher a atividade básica.
  5. Clique em Finish.

A atividade básica terá uma barra de ferramentas e um botão de ação flutuante já adicionados no layout.

Normalmente dois layouts são gerados com esta opção:

Não. Nome Tipo Descrição
activity_main.xml XML Layout Será inflado no MainActivity Layout. Tipicamente contém appbarlayout com barra de ferramentas.
2. content_main.xml XML Layout Será incluído na activity_main.xml.Você adiciona suas opiniões e widgets aqui.
3. MainActivity.java Classe Atividade principal.

Neste exemplo, eu usei uma atividade básica.

A atividade será automaticamente registrada no android_manifest.xml. As atividades Android são componentes e normalmente precisam ser registradas como um componente de aplicação.

Se você criou a sua manualmente, então registre-a dentro da <aplicação>...<aplicação> como a seguir, substituindo a MainActivity pelo nome de sua atividade:


        <activity android_name=".MainActivity">

            <intent-filter>

                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

Você pode ver que uma ação e categoria são especificadas como filtros de intenção. A categoria faz nossa MainActivity como atividade lançadora. As atividades do lançador são executadas primeiro quando o aplicativo andróide é executado.

Vantagem de criar um projeto de atividade básica

Opcionalmente, você pode escolher atividade vazia em vez de atividade básica para este projeto.

Entretanto, a atividade básica tem as seguintes vantagens:

Não. Vantagem Vantagem Não.
1. Fornece-nos uma barra de ferramentas pronta para uso, que nos dá características de barra de ação, mas facilmente personalizável
2. Fornece-nos um layout de appbar que implementa conceitos de appbar de design de material.
3. Fornece um Botão de Ação Flutuante que podemos usar prontamente para iniciar ações rápidas, especialmente em exemplos como estes.
4. Separa nossas visualizações de conteúdo e widgets personalizados dos recursos de modelagem como barra de ferramentas.

Estrutura de Projeto Gerado

O AndroidStudio irá gerar para você um projeto com configurações padrão através de um conjunto de arquivos e diretórios.

Aqui estão os mais importantes deles:

Não. Arquivo Responsabilidade Maior
1. build/ Um diretório contendo recursos que foram compilados a partir da construção da aplicação e das classes geradas por ferramentas andróides. Tal ferramenta é o arquivo R.java. O arquivo R.java normalmente contém as referências aos recursos da aplicação.
2. libs/ Para manter bibliotecas que utilizamos em nosso projeto.
3. src/main/ Para manter o código fonte de nossa aplicação. Esta é a pasta principal com a qual você trabalha.
4. src/main/java/ Contém nossas aulas de java organizadas em pacotes.
5. src/main/res/ Contém nossas pastas de recursos do projeto como segue.
6. src/main/res/drawable/ Contém nossos recursos sorteáveis.
7. src/main/res/layout/ Contém nossos recursos de layout.
8. src/main/res/menu/ Contém nosso menu de recursos código XML.
9. src/main/res/values/ Contém nossos recursos de valores código XML. Estes definem conjuntos de pares nome-valor e podem ser cordas, estilos e cores.
10. AndroidManifest.xml Este arquivo é gerado automaticamente quando criamos um projeto androide. Ele definirá informações básicas necessárias ao sistema androide como nome do aplicativo, nome do pacote, permissões, atividades, intenções, etc.
11. build.gradle Gradle Script utilizado para construir a aplicação androide.

Atividades Android – Passe Primitivas de uma atividade para outra

Vamos ver como passar os tipos de dados primitivos de uma atividade para outra. Nós passamos:

  • Cordas
  • Inteiro
  • Boolean(Via CheckBox)

Primeira Atividade

Segunda Atividade

para uma segunda atividade e mostrá-los na segunda atividade.

Arquivos de graduação

Acrescentaremos dependências no arquivo build.gradle de nível de aplicação.

1. Build.gradle

Aqui está nosso nível de aplicação no arquivo build.gradle:

    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        testImplementation 'junit:junit:4.12'
        implementation 'com.android.support:appcompat-v7:24.2.1'
        implementation 'com.android.support:design:24.2.1'
    }

`

RECURSOS DE LAYOUT

Temos três layouts de xml;

  1. activity_main.xml
  2. content_main.xml
  3. activity_second.xml

1. activity_main.xml

  • O layout do modelo para nossa atividade principal.

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.design.widget.CoordinatorLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_fitsSystemWindows="true"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity">

        <android.support.design.widget.AppBarLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_theme="@style/AppTheme.AppBarOverlay">

            <android.support.v7.widget.Toolbar
                android_id="@+id/toolbar"
                android_layout_width="match_parent"
                android_layout_height="?attr/actionBarSize"
                android_background="?attr/colorPrimary"
                app_popupTheme="@style/AppTheme.PopupOverlay" />

        </android.support.design.widget.AppBarLayout>

        <include layout="@layout/content_main" />

        <android.support.design.widget.FloatingActionButton
            android_id="@+id/fab"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_gravity="bottom|end"
            android_layout_margin="@dimen/fab_margin"
            android_src="@android:drawable/ic_dialog_email" />

    </android.support.design.widget.CoordinatorLayout>

2. content_main.xml

  • Vamos adicionar nossos textos de edição e caixa de seleção aqui.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        app_layout_behavior="@string/appbar_scrolling_view_behavior"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity"
        tools_showIn="@layout/activity_main">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <android.support.design.widget.TextInputEditText
                android_id="@+id/nameTxt"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="Name"
                android_textSize="25dp"
                android_textStyle="bold" />

            <android.support.design.widget.TextInputEditText
                android_id="@+id/txtID"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="ID"
                android_textSize="25dp"
                android_textStyle="bold" />

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExists"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
            <Button android_id="@+id/sendBtn"
                android_layout_width="wrap_content"
                android_layout_height="60dp"
                android_text="Send"
                android_clickable="true"
                android_padding="5dp"
                android_background="#009968"
                android_textColor="@android:color/white"
                android_textStyle="bold"
                android_textSize="20dp" />
        </LinearLayout>
    </RelativeLayout>

3. activity_second.xml

  • Aqui está o código para a segunda atividade.
  • Esta atividade receberá os dados da atividade principal e os mostrará aqui.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context="com.tutorials.hp.primitivespassing.SecondActivity">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="NAME"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/nameTxtSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="ID"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/txtIDSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExistsSecond"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
        </LinearLayout>
    </RelativeLayout>

CLASSES JAVA

Temos duas classes ou duas atividades:

  1. MainActivity.java
  2. SecondActivity.java

1. Classe MainActivity

  • Nossa PrincipalAtividade.
  • Passaremos dados desta atividade ti a segunda atividade.

    package com.tutorials.hp.primitivespassing;

    import android.content.Intent;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.Button;
    import android.widget.CheckBox;

    public class MainActivity extends AppCompatActivity {

        //DECLARE VIEWS
        private TextInputEditText txtName, txtID;
        private CheckBox chkTechnologyExists;
        private Button sendBtn;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
            setSupportActionBar(toolbar);

            this.initializeViews();

            FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                }
            });

            //WHEN SEND BTN IS CLICKED,SEND
            sendBtn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    sendData();
                }
            });
        }

        /*
        REFERENCE VIEWS WE ARE USING
         */
        private void initializeViews() {
            txtName = (TextInputEditText) findViewById(R.id.nameTxt);
            txtID = (TextInputEditText) findViewById(R.id.txtID);
            chkTechnologyExists = (CheckBox) findViewById(R.id.techExists);
            sendBtn = (Button) findViewById(R.id.sendBtn);

        }

        /*
        SEND DATA TO SECOND ACTIVITY
         */
        private void sendData() {
            //GET PRIMITIVE VALUES TO SEND
            String name = txtName.getText().toString();
            int id = Integer.parseInt(txtID.getText().toString());
            Boolean techExists = chkTechnologyExists.isChecked();

            //PACK THEM IN AN INTENT OBJECT
            Intent i = new Intent(this, SecondActivity.class);
            i.putExtra("NAME_KEY", name);
            i.putExtra("ID_KEY", id);
            i.putExtra("TECHEXISTS_KEY", techExists);

            //LETS LEAVE OUR TXTS CLEARED
            txtName.setText("");
            txtID.setText("");

            //START SECOND ACTIVITY
            this.startActivity(i);
        }
    }

2. Segunda classe de atividade

  • Nossa segunda atividade.
  • Receberá dados da atividade principal e os mostrará em visualizações de texto e caixa de seleção.

    package com.tutorials.hp.primitivespassing;

    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.widget.CheckBox;
    import android.widget.Spinner;
    import android.widget.TextView;
    import android.widget.Toast;

    public class SecondActivity extends AppCompatActivity {

        //DECALRE SECOND ACTIVITY VIEWS
        TextView txtName2;
        TextView txtID2;
        CheckBox chkTechnologyExists2;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_second);

            //INITIALIZE THESE VIEWS
            txtName2 = (TextView) findViewById(R.id.nameTxtSecond);
            txtID2 = (TextView) findViewById(R.id.txtIDSecond);
            chkTechnologyExists2 = (CheckBox) findViewById(R.id.techExistsSecond);

            //RECEIVE DATA FROM MAIN ACTIVITY
            String name = getIntent().getStringExtra("NAME_KEY");
            int id = getIntent().getIntExtra("ID_KEY", 0);
            Boolean techExists = getIntent().getBooleanExtra("TECHEXISTS_KEY", false);

            //SHOW A TOAST
            Toast.makeText(SecondActivity.this, name, Toast.LENGTH_LONG).show();

            //SET THE DATA TO OUR LOCAL VIEWS
            txtName2.setText(name);
            txtID2.setText(String.valueOf(id));
            chkTechnologyExists2.setChecked(techExists);
        }
    }

Android ListActivity

Tutorial e exemplos do Android ListActivity.

Uma ListActivity é uma [atividade] (https://camposha.info/android/activity) que exibe uma lista de itens vinculados a uma fonte de dados, como um array ou Cursor. A ListActivity também nos expõe os manipuladores de eventos quando o usuário seleciona um item.

Esta é uma classe que deriva da classe Activity. ListActivity destina-se a ser usada quando o usuário planeja usar uma ListView. De fato, ela hospeda um objeto ListView que pode ser vinculado a diferentes fontes de dados, tipicamente um array ou um Cursor com resultados de consulta.

Definição da API ListActivity

ListActivity, como já dissemos, deriva da classe Activity.

public class ListActivity extends Activity

Aqui é a hierarquia da herança:

java.lang.Object
   ↳    android.content.Context
       ↳    android.content.ContextWrapper
           ↳    android.view.ContextThemeWrapper
               ↳    android.app.Activity
                   ↳    android.app.ListActivity

Lista de subclasses de atividades

Aqui estão as aulas que derivam da ListActivity:

Não. Aula Descrição
1. LauncherActivity Uma classe que apresenta uma lista de todas as atividades que podem ser realizadas para uma determinada intenção. Lança quando clicado.
2. PreferenceActivity A classe base de uma atividade para mostrar uma hierarquia de preferências ao usuário.

Screen Layout

ListActivity tem um layout padrão que consiste de uma única lista de tela completa no centro da tela. Entretanto, se desejar, você pode personalizar o layout da tela, definindo seu próprio layout de visualização com setContentView() em onCreate(). Para fazer isso, sua própria visualização DEVE conter um objeto ListView com o id "@android:id/list" (ou lista se estiver em código)

Opcionalmente, sua visualização personalizada pode conter outro objeto de visualização de qualquer tipo a ser exibido quando a visualização de lista estiver vazia. Este notificador de "lista vazia" deve ter um id "android:id/empty". Observe que quando uma visualização vazia estiver presente, a visualização de lista será escondida quando não houver dados a serem exibidos.

O código a seguir demonstra um layout de tela (feio) personalizado. Ela tem uma lista com um fundo verde, e uma mensagem alternativa vermelha "sem dados".

 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
         android_orientation="vertical"
         android_layout_width="match_parent"
         android_layout_height="match_parent"
         android_paddingLeft="8dp"
         android_paddingRight="8dp">

     <ListView android_id="@android:id/list"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#00FF00"
               android_layout_weight="1"
               android_drawSelectorOnTop="false"/>

     <TextView android_id="@android:id/empty"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#FF0000"
               android_text="No data"/>
 </LinearLayout>

Exemplos de atividade no topo da lista AndroidActivity

Nesta seção, veremos vários exemplos completos da ListActivity.

1. ListActivity e OnItemClick

Neste primeiro exemplo, veremos como preencher uma ListActivity com dados de uma matriz simples. Em seguida, veremos como lidar com eventos OnItemClick.

API’s que usamos

Comecemos definindo as várias APIs que usaremos neste exemplo.

**(a). ListActivity***

Esta classe pertence ao ‘android.app’. É uma atividade que exibe uma lista de itens vinculados a uma fonte de dados como um array ou Cursor, e expõe os manipuladores de eventos quando o usuário seleciona um item.

**(b). Pacote***.

Bundle é um mapeamento de valores de String para vários tipos de Parcelas.

Leia sobre o Bundle aqui.

**(c). Ver***.

Esta é uma classe que representa o bloco básico para os componentes da interface do usuário. Uma Vista ocupa uma área retangular na tela e é responsável pelo desenho e manuseio de eventos.

Leia sobre as vistas aqui.

**(c). ArrayAdapter***

Um arrayadapter é um BaseAdapter concreto que é apoiado por um conjunto de objetos arbitrários. Por padrão esta classe espera que a identificação do recurso fornecido faça referência a um único TextView.

Leia sobre o ArrayAdapter aqui.

**(d). ListView***

A ListView é uma visão que mostra itens em uma lista de rolagem vertical. Os itens são provenientes do ListAdapter associado a esta visão.

Leia sobre a ListView aqui.

MyListActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;

public class MyListActivity extends ListActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_my_list);

        String[] values = new String[] { "Android", "iPhone", "WindowsMobile",
                "Blackberry", "WebOS", "Ubuntu", "Windows7", "Max OS X",
                "Linux", "OS/2" };
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,values);
        setListAdapter(adapter);

    }
    @Override
    protected  void  onListItemClick(ListView l, View v, int position, long id){

        String item = (String) getListAdapter().getItem(position);
        Toast.makeText(this, item + " selected", Toast.LENGTH_LONG).show();

    }
}

activity_my_list.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    tools_context="com.codekul.myandroidlistactivity.MyListActivity">

    <TextView
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_text="Hello World!"
        app_layout_constraintBottom_toBottomOf="parent"
        app_layout_constraintLeft_toLeftOf="parent"
        app_layout_constraintRight_toRightOf="parent"
        app_layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

Download

Não. Localização Link
1. GitHub Procurar
2. GitHub Criador Original: @1sumit [GitHub Criador Original: @1sumit

2. Exemplo de ListActivity e ArrayAdapter

Vamos preencher uma ListActivity com CatNames e depois lidar com os eventos Click. Não precisamos de um layout para isso.

MainActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    final String[] catNamesArray = new String[] { "Рыжик", "Барсик", "Мурзик",
            "Мурка", "Васька", "Томасина", "Бобик", "Кристина", "Пушок",
            "Дымка", "Кузя", "Китти", "Барбос", "Масяня", "Симба" };
    private ArrayAdapter<String> mAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mAdapter = new ArrayAdapter<>(this,
                android.R.layout.simple_list_item_1, catNamesArray);
        setListAdapter(mAdapter);

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);
    }
}

Download

Não. Localização Link
1. GitHub Download
2. GitHub Browse [GitHub Browse GitHub Browse
2. GitHub Criador Original: @disiol [GitHub Criador Original: @disiol

3. ListActivity com a AsyncTask

MainActivity.java


import android.app.ListActivity;
import android.content.Intent;
import android.os.AsyncTask;
import android.view.View;
import android.widget.Adapter;
import android.widget.ListView;

import java.util.List;

public final class AppPickerActivity extends ListActivity {

  private AsyncTask<Object,Object,List<AppInfo>> backgroundTask;

  @Override
  protected void onResume() {
    super.onResume();
    backgroundTask = new LoadPackagesAsyncTask(this);
    backgroundTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  }

  @Override
  protected void onPause() {
    AsyncTask<?,?,?> task = backgroundTask;
    if (task != null) {
      task.cancel(true);
      backgroundTask = null;
    }
    super.onPause();
  }

  @Override
  protected void onListItemClick(ListView l, View view, int position, long id) {
    Adapter adapter = getListAdapter();
    if (position >= 0 && position < adapter.getCount()) {
      String packageName = ((AppInfo) adapter.getItem(position)).getPackageName();
      Intent intent = new Intent();
      intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
      intent.putExtra("url", "market://details?id=" + packageName);
      setResult(RESULT_OK, intent);
    } else {
      setResult(RESULT_CANCELED);
    }
    finish();
  }

}

4. ListActivity – Clique para abrir uma nova atividade

Este é um exemplo de ListActivity onde analisamos como mostrar itens em uma ListActivity. Então, quando o usuário clica em um único item, abrimos uma nova atividade.

MainActivity.java

import android.app.Activity;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    String[] names;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_main);

        names = getResources().getStringArray(R.array.friends);
        setListAdapter(new ArrayAdapter<String>(this, R.layout.friend_item, names));

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        Intent in = new Intent(this, SecondActivity.class);

        in.putExtra("message", getString(R.string.show_greetings)+ " " + names[(int) id] + "!" );

        startActivity(in);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

SecondActivity.java

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class SecondActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        Intent in = getIntent();

        TextView txtName = (TextView) findViewById(R.id.txtGreetingName);
        txtName.setText(in.getStringExtra("message"));
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_second, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

activity_main.xml

<RelativeLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context=".MainActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="54dp" />

</RelativeLayout>

activity_second.xml

<RelativeLayout
     android_layout_width="match_parent"
    android_layout_height="match_parent" android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context="com.example.paulorogerio.friendgreeting.SecondActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_gravity="center_vertical|center_horizontal"
        android_id="@+id/txtGreetingName"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="55dp" />

</RelativeLayout>

friend_item.xml

<?xml version="1.0" encoding="utf-8"?>
<TextView
    android_layout_width="match_parent" android_layout_height="match_parent"
    android_text="Friend Name"
    android_gravity="center_vertical|center_horizontal"
    android_textSize="24sp"
    android_padding="20dp">

</TextView>

Download

Não. Localização Link
1. GitHub Download
2. GitHub Browse [GitHub Browse
2. GitHub Criador Original: @paulonova [GitHub Criador Original: @paulonova

5. ListActivity – População a partir de XML armazenado em ativos

Neste exemplo, veremos como usar o XmlPullParser para analisar os documentos XML armazenados no diretório Assets de nossa aplicação.
Em seguida, mostraremos os resultados analisados em xml que incluirão imagens e textos em nossa ListActivity.

Carregaremos do título de nosso documento XML, link e imagens em nossa ListView. Abriremos nosso XML a partir da pasta de ativos em um InputStream. Então teremos um método ParseXML() que analisará nosso XML utilizando o XmlPullParser.

A classe ImagesAdapter adaptará as imagens e o texto do XML para uma ListView personalizada. Ele utilizará a classe ArrayAdapter como a classe base do adaptador.

ParseXML.java

Esta ParseXML é a principal atividade.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.widget.ListView;

public class ParseXML extends Activity {
    InputStream xmlStream;
    ArrayList<ItemData> list;
    XMLHandler handler;
    ListView listView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_parse_xml);
        try {
            xmlStream = this.getAssets().open("ItemXML.xml");
            ParseXML();
            list = handler.getItemList();
            LoadImagesFromUrl();
            ImageAdapter adapter = new ImageAdapter(ParseXML.this, R.layout.imagelist, list);
            listView = (ListView) findViewById(R.id.imageList);
            listView.setAdapter(adapter);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_parse_xml, menu);
        return true;
    }

    public void ParseXML(){

        try {
            SAXParserFactory spf = SAXParserFactory.newInstance();
            SAXParser sp = spf.newSAXParser();
            XMLReader reader = sp.getXMLReader();
            handler = new XMLHandler();
            reader.setContentHandler(handler);
            reader.parse(new InputSource(xmlStream));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void LoadImagesFromUrl(){
        for (int i=0; i<list.size();i++){
            LoadChart loader = new LoadChart(ParseXML.this, list.get(i).link);
            loader.execute();
            list.get(i).bitmap = loader.getBitmap();
        }
    }
}

ItemData.java

Esta é a classe modelo e representa um único elemento XML que compreenderá nosso item ListView. Teremos título, link, bem como bitmap.

package com.example.parsexml;

import android.graphics.Bitmap;

public class ItemData {
    String title;
    String link;
    Bitmap bitmap;
    public Bitmap getBitmap() {
        return bitmap;
    }
    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getLink() {
        return link;
    }
    public void setLink(String link) {
        this.link = link;
    }

}

ImageAdapter.java

Esta é a classe do adaptador personalizado, derivada do ArrayAdapter'. Ele utiliza o padrão ViewHolder para segurar as vistas a serem recicladas. Esse ViewHolder é apenas uma classe simples para manter os widgets TextView e ImageView para reciclagem, ao invés de serem inflados toda vez que o método getView()` é chamado.

package com.example.parsexml;

import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class ImageAdapter extends ArrayAdapter{
    ViewHolder holder;
    Context ctx;
    List<ItemData> list;
    LoadChart loader;
    public ImageAdapter(Context context, int textViewResourceId,
            List<ItemData> objects) {
        super(context, textViewResourceId, objects);
        ctx = context;
        list = objects;

        // TODO Auto-generated constructor stub
    }
    private class ViewHolder{
        TextView titleView;
        ImageView img;
    }
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        // TODO Auto-generated method stub
        if(convertView == null){
            LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(ctx.LAYOUT_INFLATER_SERVICE);
            convertView = inflater.inflate(R.layout.imagelist, null);
            holder = new ViewHolder();
            holder.img = (ImageView) convertView.findViewById(R.id.linkimage);
            holder.titleView = (TextView) convertView.findViewById(R.id.title);

            convertView.setTag(holder);

        }
        else{
            holder = (ViewHolder) convertView.getTag();
        }
        holder.titleView.setText(list.get(position).title);
        loader = new LoadChart(ctx, holder.img, list.get(position).link);
        loader.execute();

        return convertView;

    }

}

XMLHandler.java

Esta classe derivará da classe org.xml.sax.helpers.DefaultHandler. DefaultHandler é a classe base Default para manipuladores de eventos SAX2. Nesta classe, nós substituímos vários métodos como o startElement(), endElement() e characters().

package com.example.parsexml;

import java.util.ArrayList;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class XMLHandler extends DefaultHandler{
    private ArrayList<ItemData> itemList = new ArrayList<ItemData>();
    String value = "";
    ItemData item = null;
    Boolean flag = false;

    public ArrayList<ItemData> getItemList() {
        return itemList;
    }

    public void setItemList(ArrayList<ItemData> itemList) {
        this.itemList = itemList;
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        if(flag){
            value = new String(ch, start, length);
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        flag = false;

        if(localName.equalsIgnoreCase("title")){
            item.setTitle(value);
        }
        if(localName.equalsIgnoreCase("link")){
            item.setLink(value);
        }
        if(localName.equalsIgnoreCase("item")){
            itemList.add(item);
        }

    }

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        flag = true;
        value = "";
        if(localName.equalsIgnoreCase("item")){
            item = new ItemData();

        }
    }

}

LoadChart.java

Esta classe será derivada da classe abstrata asynctask. Assim, isto nos permite carregar nosso XML em um fio separado.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;

import android.app.ProgressDialog;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.ImageView;

public class LoadChart extends AsyncTask<Void, Void, Bitmap> {
    private ImageView img;
    private Context con;
    static String urlString ;
    Bitmap bitmap= null;

    public Bitmap getBitmap() {
        return bitmap;
    }

    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }

    public LoadChart(Context context, ImageView img1, String url) {
        this.img = img1;
        this.con = context;
        urlString = url;
    }

    public LoadChart(Context context, String url) {
        this.urlString = url;
        this.con = context;
    }

    @Override
    protected void onPreExecute() {

        super.onPreExecute();
    }

    @Override
    protected Bitmap doInBackground(Void... params) {

        Bitmap bitmap = DownloadImage();

        return bitmap;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        this.bitmap = bitmap;
        //img.setImageBitmap(bitmap);

    }

    private static InputStream OpenHttpConnection(String urlString)
            throws IOException {

        Log.d("palval", "OpenHttpConnection");
        InputStream in = null;
        int response = -1;

        URL url = new URL(urlString);
        URLConnection conn = url.openConnection();

        if (!(conn instanceof HttpURLConnection))
            throw new IOException("Not an HTTP connection");

        try {
            HttpURLConnection httpConn = (HttpURLConnection) conn;
            httpConn.setAllowUserInteraction(false);
            httpConn.setInstanceFollowRedirects(true);
            httpConn.setRequestMethod("GET");
            httpConn.connect();

            response = httpConn.getResponseCode();

            if (response == HttpURLConnection.HTTP_OK) {
                in = httpConn.getInputStream();
            }

            String res = Integer.toString(response);
        } catch (Exception ex) {
            throw new IOException("Error connecting");
        }
        return in;
    }

    public static Bitmap DownloadImage() {
        Log.d("palval", "DownloadImage");
        Bitmap bitmap = null;
        InputStream in = null;
        try {

             //in = OpenHttpConnection("https://chart.googleapis.com/chart?chs=440x220&chd=t:60,40&cht=p3&chl=Hello|World");
            in = OpenHttpConnection(urlString);
            bitmap = BitmapFactory.decodeStream(in);
            in.close();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return bitmap;
    }

}

**Download***

Não. Localização Link
1. GitHub Download
2. GitHub Browse [GitHub Browse
2. GitHub Criador Original: @bansal2211 [GitHub Criador Original: @bansal2211

Android ListActivity – Com Imagens,Texto e OnItemClick ArrayAdapter

Lista de AndróidesAtividade Imagens Texto

Este é um tutorial de visualização de lista personalizado para andróides. Como mostrar imagens e texto em uma visualização de lista. Estamos usando o arrayadapter como nosso adaptador de escolha.

Seção 1 : Classe do Adaptador Personalizado

Esta é nossa classe CustomAdapter. Ele subclasse android.widget.ArrayAdapter. Leia mais sobre o ArrayAdapter aqui.

Esta é nossa classe Adapter.

    package com.tutorials.customlistviewarrayadapter;

    import android.content.Context;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.ArrayAdapter;
    import android.widget.ImageView;
    import android.widget.TextView;

    public class CustomAdapter extends ArrayAdapter<String>{

      final Context c;
      String[] values;

      //CONSTRUCTOR
      public CustomAdapter(Context context, String[] values) {
        super(context,R.layout.activity_main, values);

        this.c=context;
        this.values=values;

      }

      @Override
      public View getView(int position, View convertView, ViewGroup parent) {

        LayoutInflater inflator=(LayoutInflater) c.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        //INFLATE OUR XML LAYOUT TO ROW
        View row=inflator.inflate(R.layout.activity_main, parent,false);

        //DECLARE FIELDS CONTAINED IN OUR LAYOUR
        TextView tv=(TextView) row.findViewById(R.id.textView1);
        ImageView img=(ImageView) row.findViewById(R.id.imageView1);

        //GET AN ITEM FROM ARRAY
        String item=values[position];

        //DYNAMICALLY SET TEXT AND IMAGES DEPENDING ON ITEM IN ARRAY
        if(item.equals("android"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.android);
        }else if(item.equals("java"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.java);
        }else if(item.equals("c#"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.csharp);
        }else if(item.equals("mysql"))
        {
          tv.setText(item+" Database language");
          img.setImageResource(R.drawable.mysql);
        }else if(item.equals("access"))
        {
          tv.setText(item+" Database language");
          img.setImageResource(R.drawable.access);
        }else if(item.equals("excel"))
        {
          tv.setText(item+" Microsoft");
          img.setImageResource(R.drawable.excel);
        }

        return row;
      }

    }

Seção 2 : MainActivity

Nossa principal atividade. Ela subclassificará a classe ListActivity.

package com.tutorials.customlistviewarrayadapter;

import android.app.ListActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ListView;
import android.widget.Toast;

public class MainActivity extends ListActivity {

  String[] languages={"android","java","c#","mysql","access","excel"};

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
      //  setContentView(R.layout.activity_main);

        CustomAdapter adapter=new CustomAdapter(this, languages);
        setListAdapter(adapter);
    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        // TODO Auto-generated method stub
        super.onListItemClick(l, v, position, id);

        String item=(String) getListAdapter().getItem(position);

        Toast.makeText(getApplicationContext(),"Welcome to "+ item+" Programming language", Toast.LENGTH_SHORT).show();
    }
}

Seção 3 : Layouts

ActivityMain.xml

Nossa principal atividade é o layout.

    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context=".MainActivity" >

        <ImageView
            android_id="@+id/imageView1"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentLeft="true"
            android_layout_alignParentTop="true"
            android_layout_marginLeft="16dp"
            android_layout_marginTop="17dp"
            android_src="@drawable/ic_launcher" />

        <TextView
            android_id="@+id/textView1"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignBottom="@+id/imageView1"
            android_layout_alignParentRight="true"
            android_layout_alignTop="@+id/imageView1"
            android_layout_marginLeft="16dp"
            android_layout_toRightOf="@+id/imageView1"
            android_text="TextView" />

    </RelativeLayout>

Bom dia.