Bloco de Notas Exercício 1

Neste exercício, você vai construir uma lista de notas simples que permite ao usuário

adicionar novas notas, mas não editá-los. O exercício demonstra:

Os fundamentos da ListActivitiese manipulação menu de opções e

criando.

Como utilizar um banco de dados SQLite para armazenar as notas.

Como vincular dados de um cursor do banco de dados em um ListView usando

um SimpleCursorAdapter.

Os princípios básicos de layouts de telas, incluindo a forma de expor uma visão

de lista, como você pode adicionar itens ao menu de atividade, e como a atividade

manipula as seleções do menu. [ Exercício 1 ] [ Exercício 2 ] [ Exercício 3 ] [ Crédito Extra ]

Passo 1

Abra o Notepadv1 projeto no Eclipse.

Notepadv1 é um projeto que é fornecido como um ponto de partida. Ele cuida de

alguns dos trabalhos clichê que você já viu se você seguiu as Olá, Mundo tutorial.

1. Iniciar um novo projeto Android, clicando em File> New> Project Android.

2. No Android diálogo New Project, selecione Criar projeto de fonte existente.

3. Clique em Procurar e navegue até onde você copiou

o NotepadCodeLab(baixados durante a instalação ) e selecione Notepadv1 .

4. O nome do projeto e outras propriedades devem ser preenchidos

automaticamente para você. Você deve selecionar o Build-alvo é recomendável

selecionar um alvo com a versão mais baixa plataforma disponível. Também adicione

um número inteiro para o campo de Melhores SDK versão que corresponda ao nível

da API do Build-alvo selecionado.

5. Clique em Concluir. O Notepadv1projeto deve ser aberto e visível no seu

explorador pacote Eclipse.

Se você ver um erro sobreAndroidManifest.xml , ou alguns problemas relacionados

com um arquivo zip Android, clique direito sobre o projeto e selecione Android

Ferramentas> Corrigir Propriedades do projeto. (O projeto está procurando no local

errado para o arquivo da biblioteca, esta irá corrigi-lo para você.)

Passo 2

Acessar e modificar dados

Para este exercício, nós estamos usando um banco de dados SQLite para armazenar os

dados.Isso é útil se apenas o seu aplicativo precisa acessar ou modificar os dados. Se você

desejar para outras actividades para acessar ou modificar os dados, você tem que expor os

dados usando umContentProvider .

Se você está interessado, você pode descobrir mais sobre os provedores de conteúdo ou

todo o assunto de armazenamento de dados . A amostra de bloco de notas

na samples/ pasta do SDK também tem um exemplo de como criar um ContentProvider.

Dê uma olhada na NotesDbAdapterclasse - esta classe é fornecida para encapsular

acesso a dados para um banco de dados SQLite que irá realizar anotações nossos

dados e nos permite atualizá-lo.

No topo da classe são algumas das definições constantes que serão usadas na

aplicação de olhar para cima os dados de nomes de domínio adequado no banco de

dados. Há também uma seqüência de criação de banco de dados definido, que é

usado para criar um esquema novo banco de dados se não existir.

Nosso banco de dados terá o nome data , e tem uma única tabela chamada notes ,

que por sua vez, tem três campos: _id ,title e body . O _id é nomeado com uma

convenção sublinhado usado em um número de lugares no interior do Android SDK e

ajuda a manter uma faixa de estado.O _id geralmente tem que ser especificado ao

consultar ou atualizar o banco de dados (nas projecções da coluna e assim por

diante). Os outros dois são campos de texto simples que irá armazenar os dados.

O construtor para NotesDbAdapter tem um contexto, que lhe permite comunicar-se

com os aspectos do sistema operacional Android. Isso é muito comum para as classes

que precisam tocar o sistema Android, de alguma forma. A classe de atividade

implementa a classe Context, de modo geral você só vai passar this a partir de sua

atividade, quando precisar de um contexto.

O open() método chama-se uma instância de DatabaseHelper, que é o nosso local de

implementação da classe SQLiteOpenHelper. Ele chamagetWritableDatabase() ,

que trata da criação / abertura de um banco de dados para nós.

close() apenas fecha o banco de dados, liberando recursos relacionados com a

ligação.

createNote() tem cordas para o título e corpo de uma nova nota, em seguida, cria a

nota no banco de dados. Assumindo que a nova nota é criada com êxito, o método

também retorna a linha _id valor para o recém-criado nota.

deleteNote() toma um ROWID para uma nota especial, e exclui que a nota do banco

de dados.

fetchAllNotes() emite uma consulta para retornar um Cursor sobre todas as notas

do banco de dados. A query() é chamada de análise estima e compreensão.O

primeiro campo é o nome da tabela de banco de dados para consulta (neste

casoDATABASE_TABLE é "notas"). A próxima é a lista de colunas que deseja que seja

retornada, neste caso queremos que o _id, title e body colunas de forma que estes

são especificados na matriz de String. Os campos restantes são, em

ordem: selection , selectionArgs ,groupBy , having e orderBy . Tendo todos

estes null significa que queremos todos os dados, não precisam de agrupamento, e

tomará a forma padrão.Veja SQLiteDatabase para mais detalhes.

Nota: Um Cursor é retornado ao invés de uma coleção de linhas. Isso permite

que o Android a utilização eficaz dos recursos - em vez de colocar grandes

quantidades de dados diretamente na memória do cursor irá recuperar e divulgar

dados, uma vez que é necessário, que é muito mais eficiente para tabelas com

muitas linhas.

fetchNote() é semelhante aofetchAllNotes() , mas só fica uma nota com

o rowid especificados. Ele usa uma versão ligeiramente diferente

daSQLiteDatabase query() método. O primeiro parâmetro (em true) indica que

estamos interessados em um resultado distinto. O parâmetro de seleção (o quarto

parâmetro) foi especificado para pesquisar apenas para a linha "onde _id ="

o rowidpassamos dentro Então nós estamos retornou um cursor na linha um.

E, finalmente, updateNote() tem umtítulo, ROWID e corpo, e usa

umContentValues exemplo, para atualizar a nota do dado ROWID.

Etapa 3

Layouts e atividades

A maioria das classes de atividades terá um esquema que lhes estão associados. O layout vai

ser o "rosto" da atividade para o usuário. Neste caso, nosso layout vai assumir toda a tela e

fornecer uma lista de notas.

layouts de tela cheia não são a única opção para uma atividade no entanto. Você também pode

querer usar um layout flutuante (por exemplo, umdiálogo ou alerta ), ou talvez você não

precisa de um layout de todo (a atividade será invisível para o usuário, a menos que você

especificar algum tipo de layout para que ele use ).

Abra o notepad_list.xml arquivo emres/layout e dar uma olhada nisso.(Você

pode ter que acertar o guia xml, no fundo, a fim de ver a marcação XML.)

Este é um arquivo de definição de layout principalmente vazio. Aqui estão algumas

coisas que você deve saber sobre um arquivo de layout:

Todos os arquivos de layout Android deve começar com a linha de cabeçalho

XML: <?xml version="1.0" encoding="utf-8"?> .

A próxima definição, muitas vezes (mas nem sempre) ser uma definição de

layout de algum tipo, neste caso, umLinearLayout .

O namespace XML do Android devem ser sempre definidos na componente de

nível superior ou layout do XML para que android: tags podem ser usados pelo resto

do arquivo:

xmlns:android="http://schemas.android.com/apk/res/android"

Etapa 4

Precisamos criar o layout para segurar nossa lista. Adicione o código dentro

doLinearLayout elemento para o arquivo inteiro é assim:

<? Xml version = "1.0" encoding = "utf-8"?>

xmlns LinearLayout <: android =

"http://schemas.android.com/apk/res/android"

layout_width = "wrap_content": android

layout_height = "wrap_content">: android

<ListView android: id = "@ android: id / list"

layout_width = "wrap_content": android

layout_height = "wrap_content" />: android

<TextView android: id = "@ android: id / vazia"

layout_width = "wrap_content": android

layout_height = "wrap_content": android

text = "string @ no_notes" />: android

</ LinearLayout>

O símbolo @ nas cordas ID doListView e TextView tags significa que o

analisador XML deve analisar e ampliar o resto da seqüência de identificação e

utilização de um recurso de identificação.

O ListView e TextView pode ser pensada como duas visões alternativas, das

quais apenas uma será exibido uma vez. ListView será utilizado quando há notas a

serem mostradas, enquanto o TextView (que tem um valor padrão de "Não Notas

ainda!", Definida como um recurso de seqüência de caracteres

emres/values/strings.xml ) será exibido se não houver todas as notas para

mostrar.

A list e empty identificações são fornecidos por nós, a plataforma Android,

assim, devemos prefixar o idcom o android: (por exemplo,@android:id/list ).

The View com o empty id é usado automaticamente quando

oListAdapter não tem dados para o ListView. O ListAdapter sabe olhar para este

nome por padrão.Alternativamente, você pode alterar o modo de exibição padrão vazio

usandosetEmptyView(View) no ListView.

Mais amplamente, o android.Rclasse é um conjunto de recursos predefinidos

fornecidos por você, a plataforma, enquanto seu projeto de Rclasse é o conjunto de

recursos do projeto definiu. Recursos encontrados na android.R classe de recurso

podem ser usados nos arquivos XML usando o android: o prefixo do espaço de

nome (como podemos ver aqui).

Etapa 5

Recursos e da classe R

As pastas sob res / no projeto Eclipse são de recursos. Existe uma estrutura

específica para as pastas e arquivos sob / RES.

Recursos definidos nestas pastas e arquivos terão entradas correspondentes na classe de R

permitindo que eles sejam facilmente acessados e utilizados a partir de sua aplicação. A classe

I é gerada automaticamente com o conteúdo da res / pasta plugin do eclipse (ou por AAPT se

você usar as ferramentas de linha de comando). Além disso, eles serão agrupados e

implantado para você como parte do pedido.

Para fazer a lista de notas no ListView, também precisamos de definir uma visão para

cada linha:

1. Criar um novo arquivo em res/layoutchamado notes_row.xml .

2. Adicione o seguinte conteúdo (nota: mais uma vez o cabeçalho XML é usado,

eo primeiro nó define o Android namespace XML)

<? Xml version = "1.0" encoding = "utf-8"?>

<TextView android: id = "+ @ id/text1"

xmlns: android = "http://schemas.android.com/apk/res/android"

layout_width = "wrap_content": android

layout_height = "wrap_content" />: android

Esta é a vista que será usado para cada linha de título notas - tem apenas um campo

de texto na mesma.

Neste caso, criamos um novo id chamada text1 . A + após o @ na string id indica que

o ID deve ser automaticamente criado como um recurso se ele já não existir, por isso

estamos definindo text1 na mosca e, em seguida, usá-lo.

3. Salve o arquivo.

Abra o R.java classe no projeto e olhar para ele, você verá novas definições

paranotes_row e text1 (nossas definições novo) o que significa que agora pode ter

acesso a estes a partir do nosso código.

Passo 6

Em seguida, abra o Notepadv1 classe na fonte. Nas etapas seguintes, vamos alterar

essa classe para tornar-se um adaptador de lista e exibir nossas notas, e também nos

permite adicionar novas notas.

Notepadv1 vão herdar uma subclasse daActivity chamada de ListActivity , que

tem a funcionalidade extra para acomodar os tipos de coisas que você pode querer

fazer uma lista, por exemplo: a exibição de um número arbitrário de itens da lista em

linhas na tela, movendo-se através da itens da lista, e permitindo que eles sejam

selecionados.

Dê uma olhada através do código existente no Notepadv1 classe. Há um momento

sem uso privado um campo chamadomNoteNumber que vamos usar para criar títulos

de nota numerada.

Há também três métodos substituir

definidos: onCreate ,onCreateOptionsMenu eonOptionsItemSelected , precisamos

preencher essas Saída:

onCreate() é chamado quando a atividade é iniciada - é um pouco como o

principal "método" para uma atividade. Nós usamos isso para criar recursos e estadual

para a atividade, quando está em execução.

onCreateOptionsMenu() é usado para preencher o menu para a

atividade.Isso é mostrado quando o usuário aperta o botão de menu, e tem uma lista

de opções que pode escolher (como "Criar Nota").

onOptionsItemSelected() é a outra metade da equação do menu, é usada

para manipular os eventos gerados a partir do menu (por exemplo, quando o usuário

seleciona a opção "Criar" Nota item).

Passo 7

Alterar a herança de Notepadv1 deActivity para ListActivity :

public class Notepadv1 estende ListActivity

Nota: você terá que importarListActivity na classe Notepadv1 usando Eclipse, Ctrl-

Shift-O no Windows ou Linux, ou Cmd-Shift-O no Mac (organizar importações) vai

fazer isso por você depois que você escreveu acima mudar.

Passo 8

Preencha o corpo do onCreate() método.

Aqui vamos definir o título para a atividade (mostrado na parte superior da tela), use

onotepad_list layout que criamos em XML, criada a NotesDbAdapter exemplo, que

terá acesso a dados da nota, e preencher a lista com os títulos de notas disponíveis:

1. No onCreate método, chamarsuper.onCreate() com

osavedInstanceState parâmetro que é passado dentro

2. Call setContentView() e passarR.layout.notepad_list .

3. No topo da classe, crie uma classe de domínio privado nova

chamadamDbHelper de classeNotesDbAdapter .

4. De volta ao onCreate método, construir uma nova NotesDbAdapterinstância e

atribuí-lo ao mDbHelpercampo (passe o this para o construtor para DBHelper )

5. Ligue para o open() método emmDbHelper para abrir (ou criar) o banco de

dados.

6. Finalmente, chame um novo métodofillData() , que receberá os dados e

preencher o ListView usando o auxiliar - não temos definido este método ainda.

onCreate() agora deve ter esta aparência:

@ Override

onCreate public void (savedInstanceState Bundle) {

super.onCreate (savedInstanceState);

setContentView (R.layout.notepad_list);

mDbHelper = NotesDbAdapter novo (este);

mDbHelper.open ();

fillData ();

}

E não se esqueça que você tem amDbHelper definição de campo (à direita na

definição mNoteNumber):

mDbHelper NotesDbAdapter privado;

Passo 9

Mais sobre menus

A aplicação notepad estamos construindo apenas arranhões na superfície, com menus .

Você também pode adicionar as teclas de atalho para itens de menu , criar

submenus e até mesmoadicionar itens de menu para outras aplicações! .

Preencha o corpo doonCreateOptionsMenu() método.

Vamos agora criar o "Add Item" botão que pode ser acessada pressionando o botão

de menu do dispositivo. Nós vamos especificar que ocupam a primeira posição no

menu.

1. Em strings.xml recurso (nos termos do res/values ), adicionar uma nova

string com o nome "menu_insert" com o seu valor definido para Add Item :

<string name="menu_insert"> Adicionar item </ string>

Então, salve o arquivo e retornar paraNotepadv1 .

2. Criar uma posição no menu constante na parte superior da classe:

public static final int INSERT_ID = Menu.FIRST;

3. No onCreateOptionsMenu()método, alterar o super apelo para que capturar o

retorno booleano comoresult . Vamos devolver este valor no final.

4. Em seguida, adicione o item de menu com menu.add() .

O método geral deve agora olhar como este:

@ Override

onCreateOptionsMenu public boolean (menu Menu) {

boolean resultado super.onCreateOptionsMenu = (menu);

menu.add (0, INSERT_ID, 0, R.string.menu_insert);

resultado de retorno;

}

Os argumentos passados para add()indicam: um identificador de grupo para este

menu (nenhum, neste caso), uma ID exclusiva (definido acima), a ordem do item (zero

indica ausência de preferência), eo recurso da seqüência de usar para o item.

Etapa 10

Preencha o corpo doonOptionsItemSelected() método:

Isto está indo para lidar com o nosso novo "Adicionar Observação" item de

menu.Quando essa opção for selecionada, aonOptionsItemSelected() método será

chamado com o item.getId()definido como INSERT_ID (a constante foi utilizado

para identificar o item de menu).Nós podemos detectar isso, e tomar as ações

apropriadas:

1. Osuper.onOptionsItemSelected(item)vai chamar o método no final deste

método - que quer pegar nossos eventos em primeiro lugar!

2. Escreva uma instrução switch emitem.getItemId() .

No caso de INSERT_ID, chamar um método novo, createNote() , e retornar true,

pois temos lidado com este evento e não quero propagar através do sistema.

3. Retorna o resultado da superclasseonOptionsItemSelected() método no

final.

O conjunto onOptionsItemSelect()método deve agora olhar como este:

@ Override

public boolean onOptionsItemSelected (MenuItem item) {

switch (item.getItemId ()) {

caso INSERT_ID:

createNote ();

return true;

}

retorno super.onOptionsItemSelected (item);

}

Etapa 11

Adicionar um novo createNote() método:

Nesta primeira versão de nossa aplicação,createNote() não vai ser muito útil. Nós

simplesmente criar uma nova nota com um título que lhe é atribuída com base num

contador ("Nota 1", "Nota 2 "...) e com um corpo vazio. No momento não temos

nenhuma maneira de editar o conteúdo de uma nota, então por enquanto vamos ter

que nos contentar fazendo um com alguns valores padrão:

1. Construa o nome usando "Nota" eo contador foram definidos na classe:String

noteName = "Note " + mNoteNumber++

2. Call mDbHelper.createNote()usando noteName como título e ""para o corpo

3. Call fillData() para preencher a lista de notas (ineficiente, mas simples) -

nós vamos criar esse método seguinte.

O conjunto createNote() método deve ficar assim:

createNote private void () {

NoteName String = "Nota" + mNoteNumber + +;

mDbHelper.createNote (noteName, "");

fillData ();

}

Etapa 12

Lista de adaptadores

Nosso exemplo usa um SimpleCursorAdapterpara vincular um banco de dados Cursor em

uma ListView, e esta é uma forma comum de usar umaListAdapter . Existem outras opções

comoArrayAdapter que pode ser usado para tirar uma lista ou matriz de dados na memória e

vinculá-lo em uma lista também.

Definir o fillData() método:

Este método usaSimpleCursorAdapter, que tem um banco de dados Cursor e

vincula-la a campos fornecidos no layout. Estes campos definem os elementos da

linha da nossa lista (neste caso usamos o text1campo em

nosso notes_row.xml layout), então isso nos permite preencher a lista com as

entradas a partir de nossa base de dados.

Para fazer isso, temos de fornecer um mapeamento do title de campo no cursor

retornou, para nossa text1 TextView, que é feito através da definição de duas

matrizes: a seqüência de uma primeira matriz com a lista de colunas a partir demapa

(justo "título" na Neste caso, a partir da constanteNotesDbAdapter.KEY_TITLE ) e, a

segunda, uma matriz int contendo referências para os pontos de vista que vamos ligar

os dados no ( R.id.text1TextView).

Este é um grande pedaço de código, então vamos primeiro dar uma olhada:

fillData private void () {

/ / Pega todas as notas do banco de dados e criar a lista

de itens

Cursor c = mDbHelper.fetchAllNotes ();

startManagingCursor (c);

String [] a partir = new String [] {}

NotesDbAdapter.KEY_TITLE;

int [] a =] new int [R.id.text1 {};

/ / Agora crie uma placa matriz e configurá-lo para mostrar

usando nossa linha

notas SimpleCursorAdapter =

nova SimpleCursorAdapter (este, R.layout.notes_row, c,

de, para);

setListAdapter (notas);

}

Aqui está o que fizemos:

1. Depois de obter o cursor demDbHelper.fetchAllNotes() , nós usamos um

método chamado de Atividade startManagingCursor()que permite que o Android

para cuidar do ciclo de vida do cursor em vez de nós a necessidade de se preocupar

com isso. (Nós cobriremos as implicações do ciclo de vida no exercício 3, mas por

enquanto só sei que isso permite que o Android para fazer alguns dos nossos

trabalhos de gestão de recursos para nós.)

2. Então nós criamos uma matriz de seqüência em que declarar a coluna (s) que

queremos (apenas o título, neste caso), e um array de int que define o View (s) a que

gostaríamos de associar as colunas (estas devem estar em ordem, respectivamente

para a matriz de cadeia, mas aqui só temos um para cada).

3. Em seguida é a instanciação SimpleCursorAdapter. Assim como muitas

classes no Android, o SimpleCursorAdapter precisa de um contexto, a fim de fazer o

seu trabalho, então nós passamos this para o contexto (desde subclasses de

Atividade implementar Contexto).Passamos o notes_row Ver criamos como o

receptáculo para os dados, o cursor que acabamos de criar, e então o nosso matrizes.

No futuro, lembre-se que o mapeamento entre as colunas de e para os recursos é

feito utilizando os respectivos pedidos das duas matrizes. Se tivéssemos mais colunas

que queríamos ligar, e exibições mais para vinculá-las para, gostaríamos de

especificá-los em ordem, por exemplo, podemos usar{ NotesDbAdapter.KEY_TITLE,

NotesDbAdapter.KEY_BODY } e { R.id.text1, R.id.text2 } para ligar dois

campos para a linha (e nós também precisamos definir text2 na notes_row.xml, para o

corpo do texto). Isto é como você pode ligar campos múltiplos em uma única linha (e

receber um layout personalizado de linha também).

Se você receber erros de compilação sobre as classes não foi encontrado, Ctrl-Shift-S

ou (Cmd-Shift-O no Mac) para organizar as importações.

Etapa 13

Executá-lo!

1. Botão direito do mouse sobre aNotepadv1 projeto.

2. No menu pop-up, selecione Executar como> Android Application.

3. Se você ver uma caixa de diálogo aparecer, selecione Android Launcher como

a maneira de executar o aplicativo (você também pode usar o link na parte superior da

caixa de diálogo para definir este como padrão para a área de trabalho, o que é

recomendado, pois isso vai parar o plugin de perguntar isso toda vez).

4. Adicionar novas notas clicando no botão de menu e selecionandoAdicionar

item do menu.

Solução e Próximos Passos

Você pode ver a solução para esta classe em Notepadv1Solution do arquivo zip para

comparar com o seu próprio.

Quando estiver pronto, passe para oExercício 2 Tutorial para adicionar a capacidade

de criar, editar e apagar notas.

Neste exercício, você irá adicionar uma segunda atividade para a sua aplicação bloco

de notas, que permite ao usuário criar e editar notas. Você também vai permitir que o

usuário excluir notas existentes através de um menu de contexto. A nova actividade

assume a responsabilidade de criar novas notas de cobrança de entrada do usuário e

embalá-lo em um pacote de devolução fornecido pela intenção. Este exercício

demonstra:

A construção de uma nova atividade e adicioná-lo ao manifesto Android

Invocando outra atividade de forma assíncrona

usandostartActivityForResult()

Passagem de dados entre a atividade de objetos Bundle

Como utilizar uma tela de layout mais avançado

Como criar um menu de contexto [ Exercício 1 ] [ Exercício 2 ] [ Exercício 3 ] [ Crédito Extra ]

Passo 1

Criar um novo projeto Android usando as fontes de Notepadv2 sob

aNotepadCodeLab pasta, assim como você fez para o primeiro exercício. Se você ver

um erro sobre AndroidManifest.xml , ou alguns problemas relacionados com

umaandroid.zip arquivo, clique direito sobre o projeto e selecione Android

Ferramentas> Corrigir Propriedades do projeto.

Abra o Notepadv2 projeto e dar uma olhada:

Abra e olhe para o strings.xmlarquivo sob res/values - há várias cordas

novas, que serão utilizados para a nossa nova funcionalidade

Além disso, abrir e dar uma olhada no topo do Notepadv2 classe, você irá

notar diversas constantes foram definidos junto com um novomNotesCursor campo

usado para prender o cursor que estamos usando.

Note também que o fillData()método tem mais alguns comentários e agora

usa um novo campo para armazenar as notas Cursor. OonCreate() método é idêntico

ao do primeiro exercício. Além disso, observe que o campo de membro usado para

armazenar as notas do cursor é chamada agora mNotesCursor . O mdenota um campo

de membros e faz parte do estilo de padrões de codificação Android.

Há também um par de novos métodos de substituição

(onCreateContextMenu() ,onContextItemSelected() ,onListItemClick() eonAct

ivityResult() ) que iremos preencher abaixo.

Passo 2

Os menus de contexto deve sempre ser utilizado quando a execução de ações sobre

elementos específicos na interface do usuário. Quando você se registra uma exibição de um

menu de contexto, o menu de contexto é revelado através da realização de um "clique longo"

na componente de interface (pressione e segure o touchscreen ou destaque e mantenha

pressionada a tecla de seleção por cerca de dois segundos).

Primeiro, vamos criar o menu de contexto que permite que os usuários apagar notas

individuais. Abra a classe Notepadv2.

1. Para que cada item da lista no ListView para se inscrever no menu de contexto,

chamamosregisterForContextMenu() e passá-lo nosso ListView. Assim, no final

do onCreate() método de adicionar esta linha:

registerForContextMenu (getListView ());

Porque a nossa actividade estende a classe ListActivity, getListView()nos levará de

volta o objeto ListView local para a atividade. Agora, cada item da lista nesta ListView

irá ativar o menu de contexto.

2. Agora preencha osonCreateContextMenu() método.Este retorno é

semelhante ao menu de retorno utilizada para o menu de opções. Aqui, nós

adicionamos apenas uma linha, que irá adicionar um item de menu para apagar uma

nota. Callmenu.add() assim:

onCreateContextMenu public boolean (Menu menu Exibir v

ContextMenuInfo menuInfo) {

super.onCreateContextMenu (v, menu menuInfo);

menu.add (0, DELETE_ID, 0, R.string.menu_delete);

}

O onCreateContextMenu() de callback passa alguma outra informação para além do

objeto de Menu, como o Vista, que foi acionado para o menu e um objeto extra que

pode conter informações adicionais sobre o objeto selecionado. No entanto, não se

preocupam com estas aqui, porque nós só temos um tipo de objeto na atividade que

usa menus de contexto. Na próxima etapa, vamos lidar com a seleção do item de

menu.

Etapa 3

Agora que o temos registrado nosso ListView para um menu de contexto e definir o

nosso item de menu de contexto, temos de lidar com o retorno de chamada quando

ele é selecionado. Para isso, precisamos identificar o ID da lista do item selecionado,

em seguida, excluí-lo. Então preencha oonContextItemSelected() método como

este:

public boolean onContextItemSelected (MenuItem item) {

switch (item.getItemId ()) {

caso DELETE_ID:

info AdapterContextMenuInfo = item.getMenuInfo

(AdapterContextMenuInfo) ();

mDbHelper.deleteNote (info.id);

fillData ();

return true;

}

retorno super.onContextItemSelected (item);

}

Aqui, nós recuperamos oAdapterContextMenuInfo comgetMenuInfo() . O

campo id deste objeto nos conta a posição do item no ListView. Em seguida, passar

isso para odeleteNote() método de nossa NotesDbAdapter ea nota é suprimida. Isso

é tudo para o menu de contexto - regista agora pode ser excluída.

Etapa 4

Começando Outras Actividades

Neste exemplo, nossa intenção usa um nome de classe específico. Bem como iniciar as

intençõesdas classes que já conhecemos, sejam eles em nosso próprio aplicativo ou outro

aplicativo, também podemos criar Intenções sem saber exatamente qual a aplicação vai lidar

com isso.

Por exemplo, pode querer abrir uma página em um navegador, e por isso ainda usamos uma

intenção.Mas em vez de especificar uma classe para lidar com isso, usamos uma intenção

constante predefinida, e uma URI de conteúdo que descreve o que nós queremos

fazer. Vejaandroid.content.Intent para mais informações.

Preencha o corpo do createNote()método:

Criar uma nova Intent de criar uma nota (ACTIVITY_CREATE ) usando

o NoteEditclasse. Então o fogo Intent usando

ostartActivityForResult() chamada de método:

Intenção Intenção i = new (este, NoteEdit.class);

startActivityForResult (i, ACTIVITY_CREATE);

Esta forma de chamar a intenção alvos de uma classe específica na nossa actividade,

neste caso NoteEdit . Como a classe Intent vai precisar para se comunicar com o

sistema operacional Android para rotear solicitações, nós também temos que oferecer

um contexto ( this ).

O startActivityForResult() método dispara o Intenção de uma maneira que faz

com que um método em nossa atividade a ser chamado quando a nova atividade seja

concluída. O método em nossa atividade que recebe o callback é

chamadoonActivityResult() e vamos implementá-lo em uma etapa posterior. A

outra maneira de chamar uma atividade está usando startActivity() , mas este é

um "fogo-e-esqueça" forma de chamá-lo - desta forma, a nossa actividade não é

informado quando a atividade é concluída, e não há maneira de voltar informações

resultam da actividade chamado comstartActivity() .

Não se preocupe com o fato de queNoteEdit ainda não existe, vamos consertar isso

em breve.

Etapa 5

Preencha o corpo doonListItemClick() substituir.

onListItemClick() é um método de retorno que vamos substituir. É chamado

quando o usuário seleciona um item da lista. Ela é transmitida quatro parâmetros:

oListView objeto que ele foi invocado, oView dentro do ListView que foi clicado,

a position na lista que foi clicado, emRowId do item que foi clicado. Neste exemplo,

podemos ignorar os dois primeiros parâmetros (só temos um ListView que poderia

ser), e ignorar o mRowId também.Tudo o que interessa é a position que o usuário

selecionado. Usamos isso para obter os dados da linha correta, e empacotá-lo para

enviar para o NoteEditAtividade.

Na nossa implementação da chamada, o método cria uma Intent de editar a nota

usando o NoteEdit classe. Em seguida, adiciona os dados no pacote de extras de

Intenções, que será passado para a atividade chamada. Usamo-la para passar no

corpo do texto e do título, eo mRowIdpara a nota que está editando. Finalmente, ele

será o fogo Intenções com ostartActivityForResult() chamada de método. Aqui

está o código que pertenceonListItemClick() :

super.onListItemClick (L, V, posição, id);

Cursor mNotesCursor = c;

c.moveToPosition (posição);

Intenção Intenção i = new (este, NoteEdit.class);

i.putExtra (NotesDbAdapter.KEY_ROWID, id);

i.putExtra (NotesDbAdapter.KEY_TITLE, c.getString (

c.getColumnIndexOrThrow (NotesDbAdapter.KEY_TITLE)));

i.putExtra (NotesDbAdapter.KEY_BODY, c.getString (

c.getColumnIndexOrThrow (NotesDbAdapter.KEY_BODY)));

startActivityForResult (i, ACTIVITY_EDIT);

putExtra() é o método para adicionar itens ao pacote de extras para passar a

invocações intenção.Aqui, estamos usando o pacote para passar o título, corpo e

mRowId da nota que deseja editar.

Os detalhes da nota são puxados para fora de nossa Cursor consulta, que nos

movemos para a posição correta para o elemento que foi selecionado na lista, com

o moveToPosition() método.

Com os extras adicionados à intenção, invocamos a intenção

do NoteEditclasse passandostartActivityForResult() a intenção e o código do

pedido. (O código do pedido será devolvido

aoonActivityResult comorequestCode parâmetro.)

Nota: atribuir o campo mNotesCursor a uma variável local no início do

método. Isso é feito como uma otimização do código do Android.Acessar uma

variável local é muito mais eficiente do que acessar um campo na Dalvik VM, por

isso, fazer isso fazemos apenas um acesso ao campo, e cinco acessos para a

variável local, tornando a rotina muito mais eficiente. É recomendável que você

use essa otimização, quando possível.

Passo 6

O acima createNote() eonListItemClick() métodos usam uma invocação

assíncrona Intent. Precisamos de um manipulador para o retorno, então vamos

preencher o corpo doonActivityResult() .

onActivityResult() é o método de substituição, que será chamado quando um

retorno de atividades com um resultado.(Lembre-se de uma atividade só irá retornar

um resultado se lançou comstartActivityForResult .) os parâmetros fornecidos

para o retorno são:

requestCode - o código do pedido inicial especificado na invocação de

Intenções (ou ACTIVITY_CREATE ouACTIVITY_EDIT para nós).

resultCode - o resultado (ou erro de código) da chamada, esta deve ser zero

se estava tudo bem, mas pode ter um código diferente de zero, indicando que algo

falhou. Existem códigos de resultado padrão disponível, e você também pode criar

suas próprias constantes para indicar problemas específicos.

intent - esta é a intenção criada pela atividade retornando resultados. Ele

pode ser usado para retornar dados na intenção "extras".

A combinação destartActivityForResult() eonActivityResult() pode ser

pensado como um assíncrono RPC (remote procedure call) e constitui a forma

recomendada para uma atividade para chamar outro e compartilhar serviços.

Aqui está o código que pertence em suaonActivityResult() :

super.onActivityResult (requestCode, resultCode intenção);

Bundle intent.getExtras extras = ();

switch (requestCode) {

caso ACTIVITY_CREATE:

String title = extras.getString (NotesDbAdapter.KEY_TITLE);

corpo String extras.getString = (NotesDbAdapter.KEY_BODY);

mDbHelper.createNote (corpo do título);

fillData ();

break;

caso ACTIVITY_EDIT:

Long mRowId = extras.getLong (NotesDbAdapter.KEY_ROWID);

if (mRowId! = null) {

editTitle extras.getString String =

(NotesDbAdapter.KEY_TITLE);

editBody extras.getString String =

(NotesDbAdapter.KEY_BODY);

mDbHelper.updateNote (mRowId, editBody, editTitle);

}

fillData ();

break;

}

Estamos a lidar com ambos osACTIVITY_CREATE eACTIVITY_EDIT resultados

da actividade neste método.

No caso de criar, nós puxamos o título eo corpo do extras (recuperado da

Intenção devolvido) e usá-los para criar uma nova nota.

No caso de uma edição, que puxe o mRowId bem, e usar isso para atualizar a

nota no banco de dados.

fillData() no final assegura que tudo está atualizado.

Passo 7

A Arte de Layout

O arquivo de layout desde note_edit.xml é o mais sofisticado na aplicação estaremos

construindo, mas isso não significa que ele está sequer perto de o tipo de sofisticação que será

provável que deseja em aplicações reais Android.

Criar uma boa interface é parte arte e ciência da parte, eo resto é trabalho. Domínio

da Declarando Layout é uma parte essencial da criação de uma boa aparência aplicação

Android.

Dê uma olhada na Vistas Olá para alguns layouts exemplo e como usá-los. O projeto de

exemplo ApiDemos também é um recurso excelente para aprender a criar layouts diferentes.

Abra o arquivo note_edit.xml que tenha sido fornecida e dê uma olhada nisso. Este

é o código de interface do usuário para a Nota do Editor.

Esta é a interface mais sofisticada com que lidamos ainda. O arquivo é dado a você

para evitar problemas que podem esgueirar-se ao digitar o código. (O XML é muito

rigorosa sobre a sensibilidade do caso e estrutura, os erros nesses são a causa

comum de problemas com o layout.)

Há um novo parâmetro utilizado aqui que nós não vimos

antes:android:layout_weight (neste caso, configurado para usar o valor 1 em cada

caso).

layout_weight é usado em LinearLayouts atribuir "importância" para exibições dentro

do layout. Todas as exibições têm um padrão layout_weightde zero, significando

que eles ocupam apenas muito espaço na tela de como eles devem ser

exibidos. Atribuir um valor maior que zero irão dividir o resto do espaço disponível no

pai Vista, de acordo com o valor de cada Ver layout_weight e sua relação com o

global layout_weightespecificados no layout atual para este e ver os outros

elementos.

Para dar um exemplo: digamos que temos um rótulo de texto de edição de texto e dois

elementos em uma linha horizontal. O rótulo não tem layout_weight especificado, de

modo a ocupar o espaço mínimo necessário para render. Se o layout_weight de

cada um dos dois campos de texto elementos é definido como 1, a largura restante no

layout do pai será dividido igualmente entre eles (porque dizem que são igualmente

importantes). Se a primeira tem um layout_weight de 1, eo segundo tem

um layout_weight de 2, em seguida, um terço do espaço restante será dado ao

primeiro, e dois terços para a segunda (porque afirmamos que a segunda é mais

importante).

Este layout também demonstra como vários layouts ninho dentro da outra para atingir

um layout mais complexa e agradável.Neste exemplo, um layout horizontal linear está

aninhado a vertical para permitir que o nome do título e campo de texto a ser lado a

lado, horizontalmente.

Passo 8

Criar um NoteEdit classe que estendeandroid.app.Activity .

Esta é a primeira vez que teremos criado uma atividade sem o plugin do Eclipse

Android fazendo isso por nós. Quando você fizer isso, o onCreate() método não é

substituído automaticamente para você. É difícil imaginar uma atividade que não se

sobrepõe à onCreate() método, portanto, esta deve ser a primeira coisa a fazer.

1. Botão direito do mouse sobre acom.android.demo.notepad2pacote no

Package Explorer, e selecione Novo> Classe no menu de contexto.

2. Preencha NoteEdit para o Name:campo na caixa de diálogo.

3. No Superclass: campo, digiteandroid.app.Activity (você também pode

simplesmente Tipo de atividade e pressione Ctrl-Espaço no Windows e Linux ou Cmd-

Espaço no Mac, para invocar código assistir e encontrar o pacote certo e classe).

4. Clique em Concluir.

5. Na resultante NoteEdit classe, clique com botão direito na janela do editor e

selecione Source> Substituir / implementar métodos ...

6. Role a lista de verificação na caixa de diálogo até que você

vejaonCreate(Bundle) - e marque a caixa ao lado dele.

7. Clique em OK.

O método deve aparecer agora na sua classe.

Passo 9

Preencha o corpo do onCreate() método para NoteEdit .

Isto irá definir o título da nossa actividade de novo para dizer "Editar Nota" (uma das

seqüências definidas no strings.xml ).Ele também irá definir a exibição de conteúdo

a utilizar o nossonote_edit.xml arquivo de layout.Podemos então pegas no título e

no corpo do texto editar as vistas, e no botão de confirmação, para que nossa classe

pode usá-los para definir e obter o título da nota e do corpo, e anexar um evento para

o botão confirmar para quando é pressionado por o usuário.

Podemos, então, separar os valores que foram passados para a atividade com o

pacote de extras ligados à intenção de chamada. Vamos usá-las para preencher o

título e corpo de texto editar as vistas para que o usuário pode editá-los. Então vamos

pegar e guardar o mRowId para que possamos acompanhar o que nota o usuário está

editando.

1. Dentro onCreate() , configurar o layout:

setContentView (R.layout.note_edit);

2. Alterar o título da atividade para a "Editar" Nota seqüência:

setTitle (R.string.edit_note);

3. Encontre o EditText e Buttoncomponentes temos:

Estes são encontrados pela IDs associados a eles na classe R, e precisa ser

convertido para o tipo certo de View ( EditText para as duas visões de texto

e Button para o botão confirmar):

mTitleText = (EditText) findViewById (R.id.title);

mBodyText = (EditText) findViewById (R.id.body);

confirmButton Button = (Button) findViewById (R.id.confirm);

Note-se que mTitleText emBodyText são campos de membro (você precisa declará-

los no topo da definição de classe).

4. No topo da classe, declare uma Long mRowId campo privado para armazenar a

corrente mRowId sendo editado (se houver).

5. Continuando dentro onCreate() , adicione código para inicializar

otitle , body e mRowId do pacote de extras na intenção (se ele estiver presente):

= null mRowId;

Bundle getIntent extras = () getExtras ().;

if (extras! = null) {

String title = extras.getString (NotesDbAdapter.KEY_TITLE);

corpo String extras.getString = (NotesDbAdapter.KEY_BODY);

extras.getLong mRowId = (NotesDbAdapter.KEY_ROWID);

if (título! = null) {

mTitleText.setText (título);

}

if (corpo! = null) {

mBodyText.setText (corpo);

}

}

o Nós estamos puxando o title ebody para fora do extras pacote que

foi definido a partir da invocação de Intenções.

o Também nulo proteger o campo de texto de configuração (ou seja, nós

não queremos para definir os campos de texto para null acidentalmente).

6. Criar um onClickListener() para o botão:

Ouvintes podem ser um dos aspectos mais confusos de implementação da interface

do usuário, mas o que estamos tentando atingir, neste caso é simples. Queremos

um onClick()método a ser chamado quando o usuário pressiona o botão confirmar, e

usar isso para fazer algum trabalho e retornar os valores da nota editada para o

chamador Intenções. Fazemos isso usando algo chamado uma classe interna

anônima. Isto é um pouco confusa a olhar menos que você tenha visto antes, mas

tudo o que você realmente precisa tirar disso é que você pode consultar esse código

no futuro para ver como criar um ouvinte e anexá-lo a um botão. (Ouvintes são uma

expressão comum no desenvolvimento em Java, em particular para interfaces de

usuário.) Aqui está o ouvinte vazio:

confirmButton.setOnClickListener (View.OnClickListener novo () {

public void onClick (View vista) {

}

});

Etapa 10

Preencha o corpo do onClick() método da OnClickListener criado na última etapa.

Este é o código que será executado quando o usuário clica no botão

confirmar.Queremos que esta para pegar o título e corpo de texto dos campos de

edição de texto, e colocá-los no pacote de retorno, para que possam ser transferidos

de volta para a atividade que invocou esteNoteEdit Atividade. Se a operação é uma

edição ao invés de criar uma, também queremos colocar o mRowId no pacote para que

o Notepadv2 classe pode salvar as alterações de volta para a nota correta.

1. Criar um Bundle e colocar o título e corpo de texto para ele usar as constantes

definidas em Notepadv2 como chaves:

Bundle pacote pacote = new ();

(ToString NotesDbAdapter.KEY_TITLE, mTitleText.getText () ()).

Bundle.putString;

(ToString NotesDbAdapter.KEY_BODY, mBodyText.getText () ()).

Bundle.putString;

if (mRowId! = null) {

bundle.putLong (NotesDbAdapter.KEY_ROWID, mRowId);

}

2. Definir informações do resultado (o pacote) em uma nova intenção e terminar a

atividade:

mIntent Intenção Intenção = new ();

mIntent.putExtras (pacote);

setResult (RESULT_OK, mIntent);

finish ();

o A intenção é simplesmente o nosso suporte de dados que carrega

nosso pacote (com o título, corpo e mRowId).

o O setResult() método é usado para definir o código de resultado e

Intenção voltar a ser passado de volta para o chamador Intenções.Neste caso, tudo

funcionou, então voltamos RESULT_OK para o código de resultado.

o O finish() de chamada é usado para sinalizar que a atividade é feita

(como uma chamada de retorno). Tudo definido no resultado será retornado ao

chamador, juntamente com o controle de execução.

O pleno onCreate() método (mais apoio campos de classe) deve agora olhar como

este:

mTitleText EditText privado;

mBodyText EditText privado;

privado Long mRowId;

@ Override

protegidos onCreate void (savedInstanceState Bundle) {

super.onCreate (savedInstanceState);

setContentView (R.layout.note_edit);

mTitleText = (EditText) findViewById (R.id.title);

mBodyText = (EditText) findViewById (R.id.body);

confirmButton Button = (Button) findViewById (R.id.confirm);

= null mRowId;

Bundle getIntent extras = () getExtras ().;

if (extras! = null) {

String title = extras.getString (NotesDbAdapter.KEY_TITLE);

corpo String extras.getString = (NotesDbAdapter.KEY_BODY);

extras.getLong mRowId = (NotesDbAdapter.KEY_ROWID);

if (título! = null) {

mTitleText.setText (título);

}

if (corpo! = null) {

mBodyText.setText (corpo);

}

}

confirmButton.setOnClickListener (View.OnClickListener novo ()

{

public void onClick (View vista) {

Bundle pacote pacote = new ();

(ToString NotesDbAdapter.KEY_TITLE, mTitleText.getText

() ()). Bundle.putString;

(ToString NotesDbAdapter.KEY_BODY, mBodyText.getText ()

()). Bundle.putString;

if (mRowId! = null) {

bundle.putLong (NotesDbAdapter.KEY_ROWID, mRowId);

}

mIntent Intenção Intenção = new ();

mIntent.putExtras (pacote);

setResult (RESULT_OK, mIntent);

finish ();

}

});

}

Etapa 11

O Todo-Importante Arquivo Manifest Android

O arquivo AndroidManifest.xml é a maneira em que o Android vê o seu pedido. Este arquivo

define a categoria do aplicativo, onde ele mostra-se (ou mesmo se ele aparece) na tela do

menu ou configurações, quais as actividades, serviços e provedores de conteúdo que define, o

que intenções ele pode receber, e muito mais.

Para obter mais informações, consulte o documento de referência O arquivo

AndroidManifest.xml

Finalmente, a nova atividade tem que ser definido no arquivo de manifesto:

Antes de a nova atividade pode ser visto pelo Android, que precisa da sua entrada

própria atividade noAndroidManifest.xml arquivo. Isso é para que o sistema sabe

que ele existe e pode ser chamado. Poderíamos também especificar quais IntentFilters

implementa a atividade aqui, mas vamos ignorar isso por agora e deixe Android sabe

que a atividade está definida.

Há um manifesto editor incluído no Eclipse plugin que torna muito mais fácil editar o

arquivo AndroidManifest, e vamos usar isso.Se preferir editar o arquivo diretamente ou

não estiver usando o plugin do Eclipse, consulte a caixa no final para obter

informações sobre como fazer isso sem usar o editor de manifesto novo.

1. Dê um duplo clique sobre oAndroidManifest.xml arquivo no explorer pacote

para abri-lo.

2. Clique na guia de aplicativos na parte inferior do editor de manifesto.

3. Clique em Adicionar ... na seção de nós de aplicação.

Se você ver um diálogo com radiobuttons na parte superior, selecione o botão de rádio

de topo: "Criar um novo elemento no nível superior, em aplicação".

4. Certifique-se de "A) Atividade (" é selecionado no painel de seleção da caixa de

diálogo, e clique em OK.

5. Clique no nó "Atividade" nova, na seção nós de aplicação, em seguida,

escreva.NoteEdit no campo Nome * para a direita. Pressione Return / Enter.

O Android editor Manifesto ajuda você a adicionar entradas mais complexas para o

arquivo AndroidManifest.xml, dar uma olhada em algumas das outras opções

disponíveis (mas tome cuidado para não selecioná-los de outra forma eles serão

adicionados ao seu Manifesto). Este editor deve ajudá-lo a entender e alterar o arquivo

AndroidManifest.xml como você ir para aplicações mais avançadas Android.

Se preferir editar o arquivo diretamente, basta abrir

oAndroidManifest.xml arquivo e olhar para a fonte (use

oAndroidManifest.xml guia no eclipse editor para ver o código fonte

diretamente). Depois editar o arquivo como segue:

<activity android:name=".NoteEdit" />

Este deve ser colocado logo abaixo da linha onde se lê:

</activity> para o .Notepadv2atividade.

Etapa 12

Agora executá-lo!

Agora você deve ser capaz de adicionar notas reais a partir do menu, bem como

eliminar uma já existente. Observe que, a fim de eliminar, primeiro você deve usar os

controles direcionais no dispositivo para destacar a nota. Além disso, a seleção de um

título da nota da lista deve abrir o editor de notas para permitir que você editá-lo.Prima

confirmar quando terminar para salvar as alterações de volta para o banco de dados.

Solução e Próximos Passos

Você pode ver a solução para este exercício em Notepadv2Solution do arquivo zip

para comparar com o seu próprio.

Agora tente modificar uma nota, e então apertar o botão de volta no emulador, em vez

de o botão confirmar (o botão voltar está abaixo do botão do menu). Você verá uma

mensagem de erro surgir. É evidente que a nossa aplicação ainda tem alguns

problemas. Pior ainda, se você fez algumas alterações e aperte o botão para trás,

quando você voltar para o bloco de olhar para a nota que você mudou, você vai achar

que todas as suas alterações tenham sido perdidos. No próximo exercício, vamos

corrigir esses problemas.

Quando estiver pronto, passe para oExercício 3 Tutorial onde você irá corrigir os

problemas com o botão voltar e perdeu edições através da introdução de um ciclo de

vida adequado para a atividade Noteedit.

↑ Ir para o topo

← Voltar para o bloco de notas Tutorial

Bloco de Notas Exercício 3

Neste exercício, você irá usar callbacks evento do ciclo de vida para armazenar e

recuperar dados de estado do aplicativo.Este exercício demonstra:

Ciclo de vida e eventos como o aplicativo pode usá-los

Técnicas para manter o estado do aplicativo [ Exercício 1 ] [ Exercício 2 ] [ Exercício 3 ] [ Crédito Extra ]

Passo 1

Importação Notepadv3 em Eclipse. Se você ver um erro

sobreAndroidManifest.xml, ou alguns problemas relacionados com um arquivo zip

Android, clique direito sobre o projeto e selecione Android Ferramentas> Corrigir

Project Properties no menu de contexto.O ponto de partida para este exercício é

exatamente de onde paramos no final do Notepadv2.

O aplicativo atual tem alguns problemas - apertar o botão de volta ao editar as causas

de uma falha, e tudo o que acontece durante a edição fará com que as edições sejam

perdidas.

Para corrigir isso, vamos passar a maioria das funcionalidades para criar e editar a

nota para a classe Noteedit, e introduzir um ciclo de vida completo de edição de notas.

1. Remova o código no NoteEdit que analisa o título eo corpo do pacote de

extras.

Em vez disso, vamos usar o DBHelperclasse para acessar as notas do banco de

dados diretamente. Tudo o que precisamos passar para a atividade Noteedit é

um mRowId (mas apenas se está a editar, se criar passamos nada).Remover estas

linhas:

String title = extras.getString (NotesDbAdapter.KEY_TITLE);

corpo String extras.getString = (NotesDbAdapter.KEY_BODY);

2. Também vamos nos livrar das propriedades que estavam sendo passados

na extras Bundle, que estávamos usando para definir o título e corpo de texto editar

os valores na interface do usuário. Então delete:

if (título! = null) {

mTitleText.setText (título);

}

if (corpo! = null) {

mBodyText.setText (corpo);

}

Passo 2

Criar um campo de classe para umNotesDbAdapter no topo da classe Noteedit:

mDbHelper NotesDbAdapter privado;

Além disso, adicione uma instância doNotesDbAdapter na onCreate()método (logo

abaixo dosuper.onCreate() de chamada):

mDbHelper = NotesDbAdapter novo (este);

mDbHelper.open ();

Etapa 3

Em NoteEdit , precisamos verificar osavedInstanceState para o mRowId , no caso de

edição de nota contém um estado salvo no pacote, que deve se recuperar (o que

aconteceria se a nossa atividade perdeu o foco e depois reiniciado).

1. Substitua o código que atualmente inicializa o mRowId :

= null mRowId;

Bundle getIntent extras = () getExtras ().;

if (extras! = null) {

extras.getLong mRowId = (NotesDbAdapter.KEY_ROWID);

}

com esta:

mRowId = (savedInstanceState == null)? null:

(Long) savedInstanceState.getSerializable

(NotesDbAdapter.KEY_ROWID);

if (mRowId == null) {

Bundle getIntent extras = () getExtras ().;

mRowId extras =! = null? extras.getLong

(NotesDbAdapter.KEY_ROWID)

: Nulo;

}

2. Observe a seleção nulo parasavedInstanceState , e nós ainda precisamos

carregar mRowId dosextras pacote se não for fornecido

pelo savedInstanceState . Esta é uma abreviação operador ternário com segurança,

quer usar o valor ou nulo, se ele não está presente.

3. Observe o uso deBundle.getSerializable() em vez

de Bundle.getLong() . A codificação último retorna um longprimitivo e por isso não

pode ser usado para representar o caso quandomRowId é null .

Etapa 4

Em seguida, é preciso preencher os campos com base na mRowId se temos que:

populateFields ();

Isto vai antes doconfirmButton.setOnClickListener()linha. Nós vamos definir

esse método em um momento.

Etapa 5

Livrar-se da criação de pacote e as configurações de valor Bundle

doonClick() método do manipulador. A atividade não precisa retornar qualquer

informação extra para o chamador. E porque já não temos a intenção de voltar, vamos

usar a versão mais curta do setResult():

public void onClick (View vista) {

setResult (RESULT_OK);

finish ();

}

Nós cuidaremos de armazenar as atualizações ou novas notas no banco de dados a

nós mesmos, utilizando os métodos do ciclo de vida.

O conjunto onCreate() método deve agora olhar como este:

super.onCreate (savedInstanceState);

mDbHelper = NotesDbAdapter novo (este);

mDbHelper.open ();

setContentView (R.layout.note_edit);

mTitleText = (EditText) findViewById (R.id.title);

mBodyText = (EditText) findViewById (R.id.body);

confirmButton Button = (Button) findViewById (R.id.confirm);

mRowId = (savedInstanceState == null)? null:

(Long) savedInstanceState.getSerializable

(NotesDbAdapter.KEY_ROWID);

if (mRowId == null) {

Bundle getIntent extras = () getExtras ().;

mRowId extras =! = null? extras.getLong

(NotesDbAdapter.KEY_ROWID)

: Nulo;

}

populateFields ();

confirmButton.setOnClickListener (View.OnClickListener novo () {

public void onClick (View vista) {

setResult (RESULT_OK);

finish ();

}

});

Passo 6

Definir o populateFields() método.

privado populateFields void () {

if (mRowId! = null) {

Cursor = Nota mDbHelper.fetchNote (mRowId);

startManagingCursor (nota);

mTitleText.setText (note.getString (

note.getColumnIndexOrThrow

(NotesDbAdapter.KEY_TITLE)));

mBodyText.setText (note.getString (

note.getColumnIndexOrThrow

(NotesDbAdapter.KEY_BODY)));

}

}

Este método usa oNotesDbAdapter.fetchNote() método para encontrar o tom certo

para editar, em seguida, ele chamastartManagingCursor() a partir daActivity de

classe, que é um método de conveniência Android previsto para cuidar do ciclo de vida

do cursor. Isso vai liberar e re-criar recursos como ditado pelo ciclo de atividade de

vida, por isso não precisa se preocupar em fazer o que nós mesmos.Depois disso,

basta olhar os valores de título e corpo do cursor e preencher os elementos de

Visualização com eles.

Passo 7

Por que a manipulação de eventos do ciclo de vida é importante

Se você está acostumado a ter sempre o controle em suas aplicações, você pode não entender

por que todo esse trabalho de ciclo de vida é necessária. A razão é que no Android, você não

está no controle de suas atividades, o sistema operacional é!

Como já vimos, o modelo Android é baseado em torno de atividades de chamar uns aos

outros.Quando uma atividade chama outra, a actividade actual é interrompida pelo menos, e

pode ser morto por completo, se o sistema começa a funcionar com poucos recursos. Se isso

acontecer, a sua actividade terá o suficiente para armazenar o estado a voltar mais tarde, de

preferência no mesmo estado em que estava quando foi morto.

O Android tem um ciclo de vida definido assim . Os eventos do ciclo pode acontecer mesmo se

você não está entregando o controle para outra atividade de forma explícita. Por exemplo,

talvez uma chamada para o aparelho. Se isso acontecer, e sua atividade está em execução,

que será trocada quando a atividade assume a chamada.

Ainda no NoteEdit classe, que agora substituem os

métodosonSaveInstanceState() , onPause()e onResume() . Estes são os métodos

do ciclo de vida, a nossa (juntamente comonCreate() que já temos).

onSaveInstanceState() é chamado pelo Android, se a atividade está sendo

interrompido e pode ser morto antes que ele seja retomado! Isso significa que ele

deve armazenar todo o estado necessário re-inicializar a mesma condição quando a

atividade for reiniciado. É a contrapartida doonCreate() método, e de fato

asavedInstanceState Bundle passado para onCreate() é o mesmo pacote que

você construir como outState naonSaveInstanceState() método.

onPause() e onResume() são também métodos de cortesia. onPause() é sempre

chamado quando acaba a atividade, mesmo que instigou que (com

um finish()chamada por exemplo). Vamos usar isso para salvar a nota atual de

volta para o banco de dados. Uma boa prática é liberar os recursos que podem ser

liberados durante uma onPause() , bem como, para ocupar menos recursos, quando

em estado passivo. onResume() irá chamar o nossopopulateFields() método para

ler a nota do banco de dados novamente e preencher os campos.

Então, adicionar um pouco de espaço após o populateFields() método e adicione o

ciclo de vida de métodos que se segue:

a. onSaveInstanceState() :

@ Override

protegidos onSaveInstanceState void (outState Bundle) {

super.onSaveInstanceState (outState);

savestate ();

outState.putSerializable (NotesDbAdapter.KEY_ROWID,

mRowId);

}

Vamos definir saveState() que vem.

b. onPause() :

@ Override

OnPause protected void () {

super.onPause ();

savestate ();

}

c. onResume() :

@ Override

onResume protected void () {

super.onResume ();

populateFields ();

}

Note-se que saveState() deve ser chamado em

ambosonSaveInstanceState() e onPause()para garantir que os dados sejam

salvos.Isso ocorre porque não há garantia de queonSaveInstanceState() será

chamado e porque quando se é chamado, ele é chamado antes onPause() .

Passo 8

Definir o saveState() método para colocar os dados para o banco de dados.

savestate private void () {

String title = mTitleText.getText () toString ().;

corpo String mBodyText.getText = () toString ().;

if (mRowId == null) {

id = longo mDbHelper.createNote (título, corpo);

if (id> 0) {

mRowId = id;

}

Else {}

mDbHelper.updateNote (título, mRowId, corpo);

}

}

Note que capturar o valor de retorno decreateNote() e se uma linha de identificação

válido é retornado, que armazená-lo no mRowId campo para que possamos atualizar a

nota, no futuro, ao invés de criar um novo (que de outra forma poderia acontecer se a

vida eventos do ciclo são acionados).

Passo 9

Agora puxe o código de tratamento prévio da onActivityResult() método

naNotepadv3 classe.

Toda a nota de recuperação e atualização agora acontece dentro da NoteEdit ciclo

de vida, então todos osonActivityResult() método precisa fazer é atualizar a

exibição dos dados, nenhum outro trabalho é necessário. O método resultante deve

ficar assim:

@ Override

protegidos onActivityResult void (requestCode int, int resultCode,

a intenção Intent) {

super.onActivityResult (requestCode, resultCode intenção);

fillData ();

}

Porque a outra classe agora faz o trabalho, tudo isso tem que fazer é atualizar os

dados.

Etapa 10

Também remove as linhas que definem o título eo corpo

do onListItemClick()método (mais uma vez que já não são necessários, apenas

os mRowId é):

Cursor mNotesCursor = c;

c.moveToPosition (posição);

e também remover:

i.putExtra (NotesDbAdapter.KEY_TITLE, c.getString (

c.getColumnIndex (NotesDbAdapter.KEY_TITLE)));

i.putExtra (NotesDbAdapter.KEY_BODY, c.getString (

c.getColumnIndex (NotesDbAdapter.KEY_BODY)));

de modo que tudo o que deve ser deixado em que o método é:

super.onListItemClick (L, V, posição, id);

Intenção Intenção i = new (este, NoteEdit.class);

i.putExtra (NotesDbAdapter.KEY_ROWID, id);

startActivityForResult (i, ACTIVITY_EDIT);

Agora também é possível remover o campo mNotesCursor da classe, e defini-lo voltar

a usar uma variável local no fillData()método:

Cursor notesCursor mDbHelper.fetchAllNotes = ();

Observe que o m em mNotesCursordenota um campo de membro, por isso quando

fazemos notesCursor uma variável local, que solte a m . Lembre-se de renomear a

outras ocorrências demNotesCursor em seu fillData()método.

Executá-lo! (Usar Executar como -> Androiddo aplicativo no menu da direita, clique em

projeto de novo)

Solução e Próximos Passos

Você pode ver a solução para este exercício em Notepadv3Solution do arquivo zip

para comparar com o seu próprio.

Quando estiver pronto, passe para o Tutorial de crédito extra de exercícios, onde você

pode usar o depurador Eclipse para analisar o ciclo de eventos de vida como eles

acontecem.

Bloco de notas de crédito extra

Neste exercício, você usará o depurador para olhar o trabalho que você fez no

Exercício 3. Este exercício demonstra:

Como definir pontos de interrupção para observar a execução

Como executar o aplicativo no modo de depuração [ Exercício 1 ] [ Exercício 2 ] [ Exercício 3 ] [ Crédito Extra ]

Passo 1

Usando o trabalho Notepadv3 , colocar pontos de interrupção no código no início

doonCreate() , onPause() ,onSaveInstanceState() eonResume() métodos

na NoteEditclasse (se você não estiver familiarizado com o Eclipse, basta clicar no

estreito borda cinza no lado esquerdo da janela de edição na linha que você quer um

ponto de interrupção e escolha Alternar ponto de interrupção, você deverá ver um

ponto azul aparecer).

Passo 2

Agora inicie o notepad demo no modo de depuração:

a. Botão direito do mouse sobre aNotepadv3 projeto e no menu Debug

selecione Debug As -> Android Application.

b. O emulador do Android deve dizer "à espera de depurador para conectar-

se"brevemente e, em seguida, executar o aplicativo.

c. Se ele ficar preso na espera ... tela, saia do emulador e Eclipse, a partir da

linha de comando fazer uma adb kill-server e, em seguida reinicie o Eclipse e

tente novamente.

Etapa 3

Quando você editar ou criar uma nova nota que você deve ver os pontos de

interrupção ser atropelado e à suspensão da execução.

Etapa 4

Aperte o botão Resume para permitir a execução prosseguir (retângulo amarelo com

um triângulo verde à sua direita na barra de ferramentas Eclipse perto do topo).

Etapa 5

Experimente um pouco com os botões de confirmar e voltar, e tentar pressionando

Home e fazer mudanças outro modo. Veja o que os eventos de ciclo de vida são

gerados e quando.

O plugin do Eclipse Android não só oferece suporte a depuração excelente para o

desenvolvimento de aplicativos, mas também o apoio de perfis soberbos. Você

também pode tentar usar Traceview ao perfil de sua aplicação. Se sua aplicação está

rodando muito lento, isso pode ajudar você a encontrar os gargalos e resolvê-los.