Dois Anos de Java

  Só para não passar em branco, estou completando dois anos de Java.

  No primeiro ano escrevi esse post:  http://agorandroid.blogspot.com.br/2012/04/um-ano-de-java.html

  Terminava, assim:

"Agora estou tentando me aprofundar em processamento concorrente em Java e começando a estudar o Android 3.x para frente."

  Neste último ano, dediquei bastante tempo estudando concorrência e boas práticas em Java. E iniciei os estudos sobre "Design Patterns".

  No Android, consolidei os estudos da parte básica e já fiz uma base nas APIs mais recentes.

  Para o próximo ano, espero continuar os estudos sobre padrões, refatoração e consolidar os estudos sobre programação concorrente em Java.

  Abraços!

Nova versão da Calculadora de materiais para concreto - CalcMat

O nova versão tem uma nova opção para informar o traço: Tudo em volume - areia úmida

Na versão anterior precisávamos fazer uma série de cálculos para converter um traço tudo em volume para um traço proporcional a 1 kg de cimento.

Vejam aqui como era: http://agorandroid.blogspot.com.br/2013/04/como-usar-calcmat.html

Como nesse traço é tudo em volume e proporcional a 1 litro de cimento, precisamos informar a quantidade de água proporcional a 1 L de cimento:
Vamos pegar daquele post duas informações: 1 saco de cimento equivale a aproximadamente 36L e que precisamos de 21,5 L de água para 1 saco de cimento.
Então basta dividir 21,5 por 36, que é igual a aproximadamente 0,60.

Vamos entrar com o traço: 1:2,5:3 e água 0,60

Teste do Fragments BackStack

  Este é um teste que fiz para verificar como funciona o BackStack de Fragments.

  Tem também um exemplo de má prática de como construir um fragment acoplado a uma activity (impede reaproveitamento).

  O objetivo era só testar o funcionamento do BackStack.

 Seguem os códigos.

 activity_main.xml
<?xml version="1.0" encoding="utf-8"?> <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:baselineAligned="false" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" android:id="@+id/fragment_container1" > </LinearLayout>

 fragment1.xml
<?xml version="1.0" encoding="utf-8"?> <scrollview xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" > <LinearLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:gravity="right|center_vertical" android:orientation="vertical" > <TextView android:id="@+id/titulo" android:layout_width="match_parent" android:layout_height="match_parent" android:padding="10dp" android:textSize="48sp" android:gravity="center|center_vertical" /> <View android:layout_width="match_parent" android:layout_height="20dp" /> <LinearLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" > <Button android:id="@+id/nextfrag" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="Next Frag" /> </LinearLayout> </LinearLayout> </ScrollView>

Fragment1.java
/* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.testefragment; import android.app.Activity; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.Button; import android.widget.TextView; public class Fragment1 extends Fragment { int count; Activity hostActivity; @Override public void onAttach(Activity activity) { super.onAttach(activity); hostActivity = (MainActivity) activity; } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment1, container, false); TextView titulo = (TextView) view.findViewById(R.id.titulo); count = getArguments().getInt("count", 0); titulo.setText("Fragment n = " + count); Button btNextFrag = (Button) view.findViewById(R.id.nextfrag); btNextFrag.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { ((MainActivity) hostActivity).nextFragment(); } }); return view; } }

MainActivity.java /* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.testefragment; import android.os.Bundle; import android.app.Activity; import android.app.Fragment; import android.app.FragmentTransaction; public class MainActivity extends Activity { int count1 = 0; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (savedInstanceState != null) { count1 = savedInstanceState.getInt("count", 0); return; } Fragment newFragment = new Fragment1(); Bundle args = new Bundle(); args.putInt("count", ++count1); newFragment.setArguments(args); FragmentTransaction transaction = getFragmentManager().beginTransaction(); transaction.replace(R.id.fragment_container1, newFragment); transaction.commit(); } public void nextFragment() { Fragment newFragment = new Fragment1(); Bundle args = new Bundle(); args.putInt("count", ++count1); newFragment.setArguments(args); FragmentTransaction transaction = getFragmentManager().beginTransaction(); transaction.replace(R.id.fragment_container1, newFragment); transaction.addToBackStack(null); transaction.commit(); } @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putInt("count", count1); } }

Para testar, avance com o botão "Next Frag" e para voltar use o "Back".

Abraços.

Livro indicado em promoção

Agora eu posso dizer: eu li, então posso indicar o livro do Ricardo Lecheta.

No Portal Android, tem uma promoção de 20% de desconto.

Bons estudos!

Impressões sobre a leitura do Livro Google Android, R. Lecheta, 3ª edição

Terminei hoje o que chamei de "maratona de leitura' do livro Google Android, 3ª edição. Do capítulo 1 ao final do capítulo 15, na página 500.
Devo explicar os motivos para ler até a página 500 e também os "porquês" da leitura.
O primeiro é fácil, nesse livro a parte de conhecimentos básicos termina justamente na página 500.
Os motivos da leitura foram para responder duas questões:
1. Como estava o meu nível de conhecimento em relação aos assuntos tratados no livro, até essa página?
2. Poderia continuar a indicar o livro para um iniciante em programação Android?

Os que me acompanham pelo blog ou pelos foruns sabem que usei a segunda edição desse livro como base para meus estudos iniciais sobre a plataforma Android, e sempre o indiquei como um dos melhores livros para um iniciante.
O problema é que já se passaram quase dois anos desde que iniciei os meus estudos. Além disso, o Google já lançou quase uma dezena de versões novas da plataforma Android.
Iniciei com a API 8 e já estamos na 17.
Aproveitando o fato de que a terceira edição acaba de ser lançada, resolvi encarar o desafio para poder responder as questões acima.

Quanto à primeira pergunta, devo dizer que me surpreendi, pois, antes da leitura, não sabia nem quantificar o quanto conhecia sobre os assuntos tratados. Depois da leitura, posso dizer que somente dois assuntos não tinha conhecimento (ViewPager e Notification.Builder).
Mas, isso foi para me avaliar, não ao livro!

Os assuntos tratados nessas páginas continuam fazendo parte do que chamo de infraestrutura básica de conhecimentos necessários para um desenvolvedor Android.
Notem que são necessários, mas já não são suficientes. Com as novas versões do Android e os tablets, pode-se incluir a API Fragments, ActionBar e mais alguns tópicos como conhecimentos básicos para um desenvolvedor estar capacitado para fazer apps que suportem os diversos dispositivos disponíveis no momento.
Mas, esses novos conhecimentos devem ser adquiridos somente após os conhecimentos tratados nesse livro estarem consolidados.
Então, para resumir, o livro continua sendo indicado para um iniciante. Somente por esses capítulos, sem falar dos outros!

O livro, não é indicado apenas para um iniciante, pelos capítulos que chamo de exemplos-de-uso, servem até para os mais avançados. Eu, de minha parte, espero fazer bom proveito das novidades!

Parabenizo ambos o autor Ricardo Lecheta e a editora Novatec por mais esse livro.
Sucesso!

Android ArrayAdapter is thread-unsafe

  Estava dando uma verificada no fonte do ArrayAdapter e encontrei uma falha conceitual de concorrência, no código está sendo protegido por uma trava as operações de alteração da lista mas não as de leitura.
Então, a classe não é thread-safe.

Roteiro para estudar o livro Google Android, R.Lecheta

  Sugestão de roteiro para estudar o livro Google Android, R.Lecheta.

  Se você é um iniciante em Android e já tem um nível razoável em Java, minha sugestão para estudo é a seguinte sequência de capítulos:


Capítulo 01 - Introdução


Capítulo 02 - Configuração do ambiente


Capítulo 03 - Conceitos básicos do Android


Capítulo 04 - Activity


Capítulo 05 - Intent


Capítulo 06 - Interface gráfica – gerenciadores de layout.


Capítulo 07 - Interface gráfica – View


Capítulo 08 - Intent Filter


Capítulo 13 - Handler, Threads e AsyncTask

Sugestão: estude sobre Threads em algum livro de Java básico.


Capítulo 14 - Banco de Dados


Capítulo 09 - BroadcastReceiver


Capítulo 10 - Notification


Capítulo 11 - Service


Capítulo 12 - AlarmManager


  Neste ponto você terá uma boa base sobre a plataforma Android.
  Estude os outros capítulos de acordo com a sua necessidade ou interesse.

 Bons estudos!

Dica: Como ler código e aprender mais

  Aprendi essa técnica de ler códigos fazendo longas jornadas de depuração de códigos com problemas.

  A técnica consiste no seguinte: ao ler o código você assume um papel de um pré-compilador e de uma VM (virtual Machine)!

  Só que de um modo customizável, dependendo do foco. Explico, num momento você seta o modo de leitura, noutro o modo prospecção (nível maior de atenção, como procurando "pepitas de ouro" e/ou "lixo" no código), e finalmente o modo debug, que é o nível em que todos os sensores estão ligados verificando cada ponto, vírgula, colchetes, parenteses e ponto-e-vírgula!
  Outro detalhe, você muitas vezes deve alternar esses "modos" de trabalho num mesmo código.

  Você assume o papel de pré-compilador, quando procura possíveis erros no código.
  Você assume o papel de uma VM, quando imagina a execução do código.

  Quanto mais treinado estiver nesta técnica, maior será o sua capacidade de resolver problemas. Com um efeito colateral positivo, você vai (literalmente) aprender direto na fonte!

Abraços!

"THE DONATE LICENSE"

Estou adotando a seguinte licença de uso:


/*
 * -----------------------------------------------------------------------------
 * "THE DONATE LICENSE" (Revision 1):
 * <A H Gusukuma>  <escreveu este tutorial>.
 * Qualquer material sob essa licença é de uso livre, se for para publicar em
 * qualquer meio basta manter esta notificação.
 * Os exemplos de código não tem garantia de nenhum tipo, o uso é de sua inteira
 * responsabilidade.
 *
 * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação
 * para <alguém próximo de você>.
 *
 * -----------------------------------------------------------------------------
 */

O objetivo é chamar a atenção para um fato que ocorre com a maioria de nós: a correria do dia a dia  nos faz ficar tão centrados em nós mesmos que acabamos esquecendo dos problemas do próximo e em quanto podemos ajudar com muito pouco, bastando tomarmos a iniciativa!

Abraços!

Maratona de leitura, livro Google Android 3ª edição, R. Lecheta

  Estou iniciando uma "maratona de leitura" do livro do Lecheta.
  Na verdade uma releitura, se é que posso usar o termo, já que o livro acaba de ser lançado. Mas, como já li a 2ª edição, acho que posso falar assim.
  Pretendo fazer uma leitura direta até o capítulo sobre content provider, umas 500 páginas...
  O tamanho do livro impressiona, 800 e tantas páginas!
  Se tudo "correr" bem, até o final da semana escrevo minhas impressões sobre a leitura.

Abraços

Implementando o padrão MVC no Android, usando a API Fragments

  Comecei este tutorial com o objetivo de mostrar um exemplo de uso da API Fragments, algo simples sem grandes pretensões.
  Depois acrescentei um exemplo de uso de um Singleton. Como essa classe poderia mais tarde ser usada concorrentemente (com Threads ou AsyncTasks) usei um modelo de Singleton thread-safe.
  Para demonstrar a comunicação fragment-activity, adotei o modelo implementado via interface, conhecido como "listener". Coloquei as três formas mais comuns de usar esse padrão: Passar dados para a activity-host, consultar uma informação da activity-host e informar um evento ocorrido no fragment para que a activity-host possa tratá-lo.
  Só estava faltando a comunicação activity-fragment, então incluí isso também no exemplo.
  No final, acabei com um exemplo do padrão MVC em uma app android. Onde o M ficou por conta do Singleton, o C por conta das activities e o V com os fragments.
 Também estou testando o uso da biblioteca de compatibilidade, o agora conhecido por Android Support Library.
  Como não vou comentar o código por ser bem simples, vou dar uma visão geral do projeto.
  O projeto ficou bem simples, apesar de implementar tudo que disse aí em cima, chamei-o de ListaDe, por pura falta de inspiração, mas dá uma verificada quantas listas você tem contato no dia a dia. É composto de duas telas, uma para entrar com os dados e outra um ListView.
  Para mostrar o poder da possibilidade de reutilização de código usando fragments, coloquei três situações de uso do aplicativo:
 -Large retrato - com dois fragments na vertical;
 -Large paisagem - com dois fragments na horizontal;
 -outros casos - um fragment por tela.

  Observem que da maneira como foi implementado, toda a coordenação é exclusiva das activities (Controller), ela que atualiza os dados, ela que avisa que os dados foram alterados e ela que chama outra activity para trocar de tela.
  Por outro lado, os fragments foram implementados de tal forma que ficassem desacoplados das activities, permitindo reutilização de código.


  Aviso que só coloquei o básico, o essencial para facilitar o entendimento e deixar outros detalhes para quem desejar implementar.
  Seguem os códigos:

 string.xml
<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">ListaDe</string> <string name="action_settings">Settings</string> <string name="listaDe">ListaDe</string> <string name="digite">Digite</string> <string name="limpar">Limpar</string> <string name="salvar">Salvar</string> <string name="verlista">Ver lista</string> <string name="digite_dados">Por favor, informe os dados</string> </resources>

layout\fragment1.xml
<?xml version="1.0" encoding="utf-8"?> <scrollview xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" > <LinearLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:gravity="right|center_vertical" android:orientation="vertical" > <TextView android:id="@+id/listaDe" android:layout_width="match_parent" android:layout_height="match_parent" android:padding="10dp" android:textSize="48sp" android:text="@string/listaDe" android:gravity="center|center_vertical" /> <View android:layout_width="match_parent" android:layout_height="20dp" /> <EditText android:id="@+id/linha" android:layout_width="match_parent" android:layout_height="match_parent" android:hint="@string/digite" android:imeOptions="actionDone" android:gravity="left" android:inputType="text" android:paddingRight="15dp" android:paddingTop="5dp" android:paddingBottom="5dp" /> <LinearLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" > <Button android:id="@+id/verlista" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/verlista" /> <Button android:id="@+id/limpar" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/limpar" /> <Button android:id="@+id/salvar" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="@string/salvar" /> </LinearLayout> </LinearLayout> </ScrollView>

layout\activity1.xml
<?xml version="1.0" encoding="utf-8"?> <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:baselineAligned="false" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" android:id="@+id/fragment_container1" > <fragment class="br.com.agorandroid.listade.Fragment1" android:id="@+id/frag1" android:layout_width="fill_parent" android:layout_height="0dp" android:layout_weight="1" android:layout_margin="5dp" /> </LinearLayout>

layout\activity2.xml
<?xml version="1.0" encoding="utf-8"?> <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:baselineAligned="false" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" android:id="@+id/fragment_container2" > <fragment class="br.com.agorandroid.listade.Fragment2" android:id="@+id/frag2" android:layout_width="fill_parent" android:layout_height="0dp" android:layout_weight="1" android:layout_margin="5dp" /> </LinearLayout>

layout-large-land\activity1.xml
<?xml version="1.0" encoding="utf-8"?> <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:baselineAligned="false" android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" android:id="@+id/fragment_container3" > <fragment class="br.com.agorandroid.listade.Fragment1" android:id="@+id/frag1" android:layout_width="0dp" android:layout_height="match_parent" android:layout_weight="1" android:layout_margin="5dp" /> <fragment class="br.com.agorandroid.listade.Fragment2" android:id="@+id/frag2" android:layout_width="0dp" android:layout_height="match_parent" android:layout_weight="1" android:layout_margin="5dp" /> </LinearLayout>

layout-large-port\activity1.xml
<?xml version="1.0" encoding="utf-8"?> <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:baselineAligned="false" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="#ffffff" android:id="@+id/fragment_container5" > <fragment class="br.com.agorandroid.listade.Fragment1" android:id="@+id/frag1" android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:layout_margin="5dp" /> <fragment class="br.com.agorandroid.listade.Fragment2" android:id="@+id/frag2" android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:layout_margin="5dp" /> </LinearLayout>

MySingleton.java /* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos de código não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.listade; import java.util.ArrayList; import java.util.Collections; import java.util.List; public final class MySingleton { private static MySingleton instance = new MySingleton(); private final ArrayList<string> lista; private final List<string> unmodifiableList; private MySingleton() { lista = new ArrayList<string>(); unmodifiableList = Collections.unmodifiableList(lista); } public static MySingleton getInstance () { return instance; } public synchronized void addItem(String item) { lista.add(item); } public synchronized void clearLista() { lista.clear(); } public synchronized List<string> getLista() { return unmodifiableList; } }
Fragment1.java
/* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos de código não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.listade; import android.app.Activity; import android.os.Bundle; import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.Button; import android.widget.EditText; import android.widget.Toast; public class Fragment1 extends Fragment { OnItemInputtedListener mCallback1; public interface OnItemInputtedListener { public void onItemInputted(String linha); } OnFragment2SelectedListener mCallback2; public interface OnFragment2SelectedListener { public void onFragment2Selected(); public boolean isSinglePane(); } EditText linha; Button btLimpar, btSalvar, btVerlista; @Override public void onAttach(Activity activity) { super.onAttach(activity); try { mCallback1 = (OnItemInputtedListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " implemente OnItemInputtedListener na Activity-host"); } try { mCallback2 = (OnFragment2SelectedListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " implemente OnFragment@SelectedListener na Activity-host"); } } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment1, container, false); linha = (EditText) view.findViewById(R.id.linha); btVerlista = (Button) view.findViewById(R.id.verlista); btVerlista.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { verLista(); } }); btLimpar = (Button) view.findViewById(R.id.limpar); btLimpar.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { limpar(); } }); btSalvar = (Button) view.findViewById(R.id.salvar); btSalvar.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { salvar(); limpar(); } }); return view; } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); if (!mCallback2.isSinglePane()) { btVerlista.setVisibility(View.GONE); } } private void verLista() { mCallback2.onFragment2Selected(); } private void salvar() { String line = linha.getText().toString().trim(); if (line.equals("")) { Toast.makeText(getActivity(), this.getString(R.string.digite_dados), Toast.LENGTH_LONG).show(); return; } mCallback1.onItemInputted(line); } private void limpar() { linha.setText(""); linha.requestFocus(); } }
Fragment2.java
/* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos de código não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.listade; import android.os.Bundle; import android.support.v4.app.ListFragment; import android.widget.ArrayAdapter; public class Fragment2 extends ListFragment { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); int layout = android.R.layout.simple_list_item_1; MySingleton dados = MySingleton.getInstance(); setListAdapter(new ArrayAdapter<string>(getActivity(), layout, dados.getLista())); } @SuppressWarnings("unchecked") public void dataSetHasChanged() { ((ArrayAdapter<string>) getListAdapter()).notifyDataSetChanged(); } }
Activity1.java
/* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos de código não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.listade; import android.content.Intent; import android.os.Bundle; import android.support.v4.app.FragmentActivity; public class Activity1 extends FragmentActivity implements Fragment1.OnItemInputtedListener, Fragment1.OnFragment2SelectedListener { MySingleton singleton = MySingleton.getInstance(); @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity1); } @Override public void onItemInputted(String linha) { singleton.addItem(linha); // se for == null, significa que a tela tem 2 fragments if (findViewById(R.id.fragment_container1)==null) { Fragment2 frag = (Fragment2) getSupportFragmentManager().findFragmentById(R.id.frag2); if (frag != null) { frag.dataSetHasChanged(); } } } @Override public void onFragment2Selected() { Intent intent = new Intent(this, Activity2.class); startActivity(intent); } @Override public boolean isSinglePane() { // se for == null, significa que a tela tem 2 fragments if (findViewById(R.id.fragment_container1) == null) { return false; } else { return true; } } }
Activity2.java
/* * ----------------------------------------------------------------------------- * "THE DONATE LICENSE" (Revision 1): * A H Gusukuma escreveu este tutorial. * Qualquer material sob essa licença é de uso livre, se for para publicar em * qualquer meio basta manter esta notificação. * Os exemplos de código não tem garantia de nenhum tipo, o uso é de sua inteira * responsabilidade. * * Se lhe foi útil e se desejar e tiver condições de contribuir, faça uma doação * para alguém próximo de você. * * ----------------------------------------------------------------------------- */ package br.com.agorandroid.listade; import android.os.Bundle; import android.support.v4.app.FragmentActivity; public class Activity2 extends FragmentActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity2); } }


Rodando num celular:

Num tablet posição retrato:

Num tablet posição paisagem:

Pessoal, não comentei o código mas estejam à vontade para comentar, solicitar uma ou outra explicação, que na medida do possível tentarei responder.

Obrigado!

Como estudar um livro técnico

  Esse é um assunto interessante, como você estuda o conteúdo de um livro?
  Se você já conhece bem os assuntos tratados no livro e está interessado num tópico específico é fácil: basta ir direto no capítulo que trata sobre o tópico.
  Mas, e no caso de não conhecer assim tão bem, como você faz? Le tudo, pula alguma coisa, le fora de ordem, como faz? Já parou para se avaliar?
  Eu costumo ler tudo, dos agradecimentos ao posfácio. Passando pelo prefácio, introdução, resenhas, recomendações, etc.
  Pode parecer estranho, mas o que procuro são informações do tipo: para que serve, para que não serve, qual ou quais as motivações do autor, quem leu o que achou, que partes são fundamentais ler, qual sequencia deve ser seguida, se pode pular alguma parte sem prejuízo, etc.
  Tudo para obter um alto rendimento no estudo.
 
  É isso!
  E como você estuda?

Meus estudos

Dei uma pausa nos estudos sobre Design Patterns.

Me dediquei um pouco em praticar programação Android, fazendo o CalcMat.
Esse era um projetinho que estava engavetado por uns bons dois anos!
Aproveitei e dei uma boa revisada na API Fragments e fiz o app todo baseado nessa API.
Continuo me aprofundando nos estudos sobre programação concorrente.

Agora estou repensando sobre o que postar no Blog nos próximos meses...
Toda ajuda em forma de sugestões e idéias serão apreciadas.

Abraços

Como usar a CalcMat

  Pergunta:  Como calcular os materiais necessários para fazer uma certa quantidade de concreto?
  Resposta: Usando a CalcMat, é claro! Link para o Google play aí do lado direito em meus apps.

  Para usar a CalcMat precisamos de duas informações básicas: o traço e o volume do concreto a ser calculado.

  Para o traço, vamos usar, por exemplo, o traço em volume 1:2,5:3

  Isso traduzido significa o seguinte:
  1 volume de cimento, 2,5 volumes de areia, 3 volumes de pedra (brita 1)

  Como o programa solicita que os dados sejam proporcionais a 1 kg de cimento e areia seca, precisamos fazer umas conversões.

  Primeiro vamos converter esse traço para um saco de cimento (50 kg):
  Um saco de cimento equivale a 2 baldes de 18 litros (aproximadamente)
  Então, basta multiplicar por 36:
cimento= 1x36=36 L
areia=2,5x36=90 L
pedra 1=3x36=108 L

  Devo mencionar que essas medidas são utilizadas para fazer o concreto na própria obra, é o famoso "concreto virado na obra". E nesse caso a areia normalmente está úmida, e a areia quando úmida sofre um fenômeno físico chamado de inchamento, molhada a areia aumenta de volume.

  Vamos usar um indice de umidade de 5% e um inchamento de 27%. (São valores médios).

  Então, se a areia fosse seca, teriamos um volume menor, dividindo 90 por 1,27 = 70,9 L

  Vamos dividir tudo por 50 kg que é o peso de 1 saco de cimento:
cimento= 1x36=36 L => 50 kg : 50 = 1 kg
areia=2,5x36=90 L  - inchamento => 90:1,27 = 70,9 L : 50 = 1,42 L
pedra 1=3x36=108 L : 50 = 2,16 L

  Pronto, temos o traço em volume, proporcional a 1 kg de cimento: 1:1,42:2,16

  Falta informar  a quantidade de água, ela é informada como um fator proporcional a 1 kg de cimento, vamos usar para o exemplo o fator 0,54.

 Vamos usar como volume 1 m³, assim teremos a informação dos materiais para 1 metro cúbico de concreto.

  É complicado, não é? É muito mais tranquilo e seguro pegar os dados com o responsável técnico da obra!

  É só digitar e teremos as telas abaixo.

Notem, que na última tela do lado direito, temos os materiais para 1 saco de cimento que são os mesmos dados que usamos para chegar ao traço unitário, confirmando que fizemos as contas certas!

IMPORTANTE: esse é um exemplo, não é uma sugestão de traço.


Abraços!

PS: Nova versão: http://agorandroid.blogspot.com.br/2013/04/nova-versao-da-calculadora-de-materiais.html

App: CalcMat - Calculadora de materiais para concreto.

Acabo de publicar um novo aplicativo no Google Play: CalcMat - Calculadora de materiais para concreto.

Para usar a CalcMat precisamos de duas informações básicas: o traço e o volume do concreto a ser calculado.
O CalcMat calcula as quantidades de cimento, areia, pedra e água necessários para produzir o volume de concreto informado de acordo com o traço.

Os cálculos efetuados são:
        1- Materiais necessários para produzir uma quantidade de concreto (volume).
        2- Materiais necessários para produzir concreto com um saco de cimento de 50 kg.
        3- Materiais necessários para produzir 1 metro cúbico de concreto (informar 1 no volume).

Passo-a-passo:
1. Pegue o traço e o volume do concreto com o responsável técnico da obra;
2. Entre com os dados no CalcMat e calcule;
3. Confirme os resultados obtidos com o responsável técnico da obra (ajustes).

IMPORTANTE:
- O uso do aplicativo NÃO garante que o traço e o concreto feito de acordo com o traço estejam CORRETOS.
- Construa sob a supervisão de um profissional qualificado, ele é sua garantia de que está construindo com segurança e custos razoáveis.

https://play.google.com/store/apps/details?id=br.com.ahgusukuma.calcmat

Usando Fragments

  O uso da API Fragments permite um reaproveitamento de código incrível. Mas, para isso é necessário codificar um fragement de tal maneira que fique independente da activity host (tanto quanto possível) ou de outros fragments.

  Veja abaixo algumas formas de trocar dados entre esses componentes.

1. Fragments acessando dados da intent da activity host.

  Por exemplo no método onStart do fragment:

Bundle bundle = getActivity().getIntent().getExtras(); if (bundle != null) { int pos = bundle.getInt("posicao"); ... }

2. Fragments acessando dados setado pela activity via fragment.setArguments(bundle)

  Por exemplo no método onStart do fragment:

Bundle bundle = getArguments(); if (bundle != null) { int pos = bundle.getInt("posicao"); ... }

3. Fragments acessando dados via callback definido em uma interface

  Essa é a forma mais sofisticada, e indicada tanto para pegar dados da activity ou para passar dados para outro fragment via activity. Funciona assim: no fragment é definido uma interface com os métodos que a activity host deve implementar. Aí, no fragment, você chama esses métodos implementados na activity para solicitar dados ou para passar dados.
  Veja aqui um exemplo explicado:  http://developer.android.com/training/basics/fragments/communicating.html

  Abraços!