Criando um ListView personalizado no Android

Faaala galera!

Aqui vamos nós para mais um tutorial. Hoje vamos aprender como podemos customizar um ListView!

Se você ainda não viu o último tutorial da série, aproveite e aprenda um pouco mais sobre como manipular dados de um formulário em Android. Se você continua é preguiçoso e apenas baixou o projeto, importe-o para sua workspace. Para tal, vá em File → Import… → Existing Projects into Workspace, dentro de General.

Bora lá começar?!

Criando um ListView personalizado no Android

Vamos começar alterando nosso layout atual adicionando mais dois campos EditText, com os IDs ano e cor. Não se esqueça de criar as strings constantes ano e cor, no arquivo res/values/strings.xml.

<EditText
       android:id="@+id/ano"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:ems="10"
       android:hint="@string/ano" />
 
   <EditText
       android:id="@+id/cor"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:ems="10"
       android:hint="@string/cor" />

PS: não vou adicionar o código inteiro para não ficar muito extenso. Se você está com preguiça dificuldades, siga todo o tutorial para aprender, é claro, e depois baixe o projeto no final.

Abra a nossa Activity principal ListaCarros. Nela vamos instanciar os campos que acabamos de criar.

EditText ano, cor;
ano = (EditText) findViewById(R.id.ano);
cor = (EditText) findViewById(R.id.cor);

Agora vem a parte principal do nosso tutorial. Para customizar nossa lista, são 3 passos: criar um layout para as linhas da lista, criar as classes para adaptar a lista, e implementar a adaptação.

Primeiramente, vamos criar o layout das linhas em res/layout/linha_carro.xml. Seguindo as alterações já realizadas, vamos criar um layout básico, que irá exibir as informações de nome, ano e cor dos veículos.

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

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="match_parent"
   android:layout_height="match_parent">
 
   <TextView
       android:id="@+id/nomeCarro"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:layout_alignParentLeft="true"
       android:layout_alignParentTop="true"
       android:text="TextView"
       android:textStyle="bold" />
 
   <TextView
       android:id="@+id/anoCarro"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_alignParentLeft="true"
       android:layout_below="@+id/nomeCarro"
       android:text="TextView" />
 
   <TextView
       android:id="@+id/corCarro"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_alignBaseline="@+id/anoCarro"
       android:layout_alignBottom="@+id/anoCarro"
       android:layout_alignParentRight="true"
      android:text="TextView" />
 
</RelativeLayout>

O segundo passo é um pouco mais complicado. Precisamos criar 2 classes que irão adaptar as listas. Vamos chama-las de Adaptador, que estende ArrayAdapter, e Armazenador. Como o nome já diz, uma classe faz a adaptação e a outra armazena as informações nos lugares corretos. Deixei o código todo comentado para facilitar pra mim pra você entender.

// Classe responsável por criar um adaptador para as linhas do ListView
class Adaptador extends ArrayAdapter {
                Adaptador() {
                               // Chama o construtor da classe ArrayAdapter, passando a classe atual,
                               // um layout padrão e a lista dos itens que serão adicionados.
                               super(ListaCarros.this, android.R.layout.simple_list_item_1, listaCarros);
                }
 
                // Vamos sobrepor o método getView, pois é aqui que vamos chamar nosso layout
                // customizado
                @Override
                public View getView(int position, View convertView, ViewGroup parent) {
 
                               // Instanciando os itens necessários: linha atual, classe Armazenador
                               // e o conteúdo que será inserido
                               View linha = convertView;
                               Armazenador armazenador = null;
                               final String[] item_linha = (String[]) listaCarros.get(position);
 
                               // Neste trecho é que chamaos nosso layout. Usamos o método getLayoutInflater()
                               // e depois indicamos o layout. Também já inserimos os dados na posição atual
                               // através da classe Armazenador.
                               if (linha == null) {
                                               LayoutInflater inflater = getLayoutInflater();
                                               linha = inflater.inflate(R.layout.linha_carro, null);
                                               armazenador = new Armazenador(linha, position);
                                               linha.setTag(armazenador);
                               } else {
                                               armazenador = (Armazenador) linha.getTag();
                               }
 
                               // Apenas uma "firula". Ao clicar na linha, será exibida uma mensagem
                               // com o nome do carro. Coloque seu código dentro do método onClick().
                               linha.setOnClickListener(new OnClickListener() {
                                               @Override
                                               public void onClick(View v) {
                                                               Toast.makeText(getApplicationContext(), item_linha[0], Toast.LENGTH_SHORT).show();
                                               }
                               });
 
                               // Agora sim, vamos jogar os dados nos seus respectivos campos do layout da linha
                               armazenador.popularFormulario((String[]) listaCarros.get(position));
 
                               // Retorno obrigatório do método
                               return linha;
                }
}
 
// Classe responsável por "jogar" os dados nos campos corretos
class Armazenador {
                // Declaração dos campos
                private TextView nomeCarro = null;
                private TextView anoCarro = null;
                private TextView corCarro = null;
 
                // Construtor que instancia os campos
                Armazenador(View linha, int position) {
                               nomeCarro = (TextView) linha.findViewById(R.id.nomeCarro);
                               anoCarro = (TextView) linha.findViewById(R.id.anoCarro);
                               corCarro = (TextView) linha.findViewById(R.id.corCarro);
                }
 
                // Método para "jogar" os textos nos respectivos campos
                void popularFormulario(String[] c) {
                               nomeCarro.setText(c[0]);
                               anoCarro.setText(c[1]);
                               corCarro.setText(c[2]);
                }
}

NOTA: alguns warnings serão exibidos, porém não influenciam em nada.

Terceiro e último passo: vamos programar nossas classes de adaptação. É preciso modificar o tipo de algumas variáveis, pois antes existia apenas 1 informação (nome do carro), e agora irão existir 3.

List<String[]> listaCarros;
ArrayAdapter<String[]> adaptador;

Precisamos também trocar a instância do adaptador, e a ação do botão Salvar.

adaptador = new Adaptador();
salvar.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                               String[] c = {veiculo.getText().toString(), ano.getText().toString(), cor.getText().toString()};
                               listaCarros.add(c);
                               adaptador.notifyDataSetChanged();
                }
});

Beleza, execute o código e seja feliz!

Criando um ListView personalizado no Android

Considerações Finais

Nosso projeto começa a ficar interessante. Aprendemos a customizar nossa lista de acordo com o necessário. No próximo tutorial vamos aprender a salvar os dados em banco de dados!

Baixe o projeto atual aqui.

Até mais, pessoal!

Lista de Redes Sociais ao redor do mundo

Hello people!  Tudo joinha? Então aqui vai um post quentinho do forno pra você que é sociável e adora se comunicar na internet.  Ok, confesso esse post é pouco pra que é da área de Marketing Digital e sabe bem que a lista é interminável.

A ideia principal é te apresentar algumas redes sociais e acrescentar novas sempre que possível, assim você poderá contribuir e ficar antenado nas Redes Sociais do seu gosto.

Por favor se você tem alguma e gostaria de compartilhar comente abaixo. Espero que esse material possa te ajudar nos estudos. Até mais! 😉

Lista de Redes Sociais

Músicos e amantes de Música <3

Blip.fm
Rede social com temática musical, onde seus usuários são tratados como DJs.

Last.fm
Rede social voltada para a música. Forte presença brasileira (mais de 30.000 usuários se declaram brasileiros).

MySpace
Geral.

Palco Principal
Rede social de música.

Purevolume
Estados Unidos da América.

ShareTheMusic
Plataforma virtual para a troca legal e gratuita de música.

Spotify
Serviço de música comercial em streaming.

Países

Bebo
Rede popular na Inglaterra.

Cyworld
Coreia do Sul.

Mixi
Apenas em japonês.

Netlog
Rede Social voltada para jovens adultos europeus, de idades entre 14 e 24 anos.

Mirtesnet
Rede Social 100% Brasileira criada em 2013.

Colecionadores

Colnect
Rede social de Colecionadores do Mundo Inteiro.

Viajantes

CouchSurfing
Rede social voltado a pessoas que gostam de viajar e que gostam de hospedar viajantes em suas casas.

Leitores

Skoob
Rede social para leitores.

Filmes e Séries

Filmow

Rede social com foco em filmes e séries.

Amantes de Fotografia

Flickr
Compartilhamento de fotografias.

Instagram
Rede social online de compartilhamento de foto e vídeo que permite aos seus usuários tirar fotos e vídeos, aplicar filtros digitais e compartilhá-los em uma variedade de serviços de redes sociais.

Pinterest
Rede social de compartilhamento de fotos.

Emprego

LinkedIn
É um site para busca de colegas e ex-colegas de profissão.

Questionários

Formspring
Rede social focada em perguntas.

Ask.fm
Rede social para perguntas e respostas entre seus usuários.

Geo Localização

Foursquare
Rede social e de microblogging com ênfase na geolocalização.

Waze
Rede social colaborativa, permite compartilhar informações sobre transito, se baseia em localização geográfica.

Neutra

Friendica
Rede social descentralizada com ênfase em segurança, privacidade e comunicação com outras redes e serviços.

Jogos

Gaia Online
Anime e Jogos.

Bichos de Estimação

GoPets
Bichos de estimação virtuais.

Idiomas

Kaveris
Rede social para quem fala português.

Friendster
Geral.

Microblogging

Twitter

Rede social de microblogging.

Tumblr
Rede social (Microblogging).

Projetos

Moovia
Rede Social colaborativa voltada para o desenvolvimento de projetos em equipes.

Relacionamento

Par Perfeito
Rede de Relacionamento.

Sonico
Possui Fórum/Galeria. Site de relacionamento voltado para os povos de língua portuguesa, espanhola e inglesa.

Temas

Skyscrapercity
Rede Social para discussão de temas.

Voluntários

V2V
Rede social que reúne voluntários de acordo com suas afinidades e disposições para agir.

História

YuBliss

Rede social para auto-avaliação através de mitos modernos e histórias.

Video

Stayfilm
Rede social que permite a produção e compartilhamento de filmes com fotos e vídeos do usuário. Produção automática online com trilha sonora, efeitos e qualidade de cinema.

Youtube
Rede social e compartilhamento de vídeo.

Geral

Blaving
Rede social da PMovil.

Facebook
Maior rede social do mundo.

Google+
Compartilhamento de Conteúdo.

Hi5
Geral.

imeem
Instant messaging.

Mingle
Geral.

LiveJournal
Blogging.

VK

Rede social.

Wallop
Rede social da Microsoft.

Ello
é uma rede social virtual anti-publicitária.

Enviando E-mail com Objective-C

Bom pessoal vamos começar mais um post, hoje vamos desenvolver uma ferramenta extremamente útil e simples, vamos enviar um e-mail sem precisar sair de nosso aplicativo.

Vamos começar

Vamos começar com uma sinlge View e vamos colocar 1 botão nela, e não precisamos de mais nada em nossa interface.

TelaEmail

Para enviar e-mail é necessário que importemos o framework MessageUI ele será o responsável por enviar nossos dados, com a classe importada precisamos agora criar um componente e vamos também importar nosso delegate, nosso arquivo .h está assim:

#import <UIKit/UIKit.h>

#import <MessageUI/MessageUI.h>

@interface ViewController : UIViewController <MFMailComposeViewControllerDelegate>{

MFMailComposeViewController *formularioEmail;

}

  • (IBAction)envia:(UIButton *)sender;

Criamos também a action do botão que fará o disparo do e-mail. Agora vamos para nosso .m onde implementaremos o resto de nosso código:

Dentro de nossa action vamos implementar o seguinte código.

// dentro de nossa action vamos colocar os dados para enviar

// pré defini destinatários (não é necessário)

// NSArray *destinatario = [[NSArray alloc]initWithObjects:@”contato@yesbr.com.br”, nil];

//

// [formularioEmail setToRecipients:destinatario];

formularioEmail = [[MFMailComposeViewController alloc]init];

formularioEmail.mailComposeDelegate = self;

// setSubject adiciona um assunto ao email

[formularioEmail setSubject:@”Email de teste”];

// temos agora o corpo da mensagem

[formularioEmail setMessageBody:@”Enviamos nossa mensagem” isHTML:NO];

[self presentModalViewController:formularioEmail animated:YES];

A vantagem de usar esses métodos que já temos tudo criado pelo celular apenas chamamos o formulário de e-mail, o que torna todo o processo muito mais simples, e intuitivo para o usuário.

Os comentários já deixam o código bem fácil de entender mas vamos explicar apenas a questão de destinatários, em algumas situações, o aplicativo tem que enviar e-mail para um destinatário específico por exemplo um formulário de contato enviará o e-mail para o contato, nessa situação podemos implementar o setToRecipents e colocamos os destinatários em um array para poder enviar o e-mail a vários usuários por vez.

Feito a implementação de nossa ação para envio vamos obter a resposta se nosso e-mail foi ou não enviado. Para isso vamos implementar o seguinte método nele com base na resposta celular mostra um alerta se o e-mail foi ou não enviado com sucesso.

-(void)mailComposeController:(MFMailComposeViewController *)controller

didFinishWithResult:(MFMailComposeResult)result error:(NSError *)error{

UIAlertView *mensagem;

if (result) {

mensagem = [[UIAlertView alloc]initWithTitle:@”Enviado” message:@”Email enviado com sucesso” delegate:self cancelButtonTitle:@”ok” otherButtonTitles:nil, nil];

}

if (error) {

mensagem = [[UIAlertView alloc]initWithTitle:@”Erro” message:@”Erro ao enviar mensagem” delegate:self cancelButtonTitle:@”ok” otherButtonTitles:nil, nil];

}

[mensagem show];

[self dismissViewControllerAnimated:YES completion:nil];

}

Bom pessoal esse projeto foi extremamente simples, porém é bem interessante para implementar no seus apps.

Como manipular dados de um formulário em Android

Fala galera!

Continuando nossa série de tutoriais Android, vamos ver hoje como manipular dados de um formulário em Android. Vamos obter os dados dos campos e salvar na memória do aparelho.

Se você ainda não viu o último tutorial da série, aproveite e aprenda um pouco mais sobre layouts XML em Android. Se você é preguiçoso e apenas baixou o projeto, importe-o para sua workspace. Para tal, vá em File → Import… → Existing Projects into Workspace, dentro de General.

Feito isso, mãos à obra!

Como manipular dados de um formulário em Android

Vamos modificar nossa Activity principal ListaCarros. Vamos fazer com que, ao apertar o botão Salvar, a aplicação salve os dados digitados na memória do aparelho. Lembre-se que ao fechar o aplicativo, é feita a limpeza da memória e os dados são apagados.

Logo no primeiro instante, devemos instanciar todos os itens que vamos utilizar, neste caso serão os dois campos EditText, o botão Button e a lista ListView. Mas primeiro vamos declarar os componentes. Esse código é adicionado antes do método onCreate(). Vamos também instanciar um objeto do tipo List<String>que irá armazenar os dados salvos para exibir na nossa lista, e um objeto do tipo ArrayAdapter<String> que irá manter os dados salvos na lista.

EditText veiculo;
Button salvar;
ListView lista;
List<String> listaCarros;
ArrayAdapter<String> adaptador;

Note que, ao dar Ctrl C + Ctrl V digitar esse código, o Eclipse acusará erro. Isso acontece pois ao declarar componentes, devemos importar suas classes respectivas. E para fazer isso automaticamente, no Eclipse, basta apertar Ctrl + Shift + O.

Agora sim, vamos instanciar os objetos. Vamos utilizar a função nativa findViewById, retorna uma View (componente) de acordo com o parâmetro passado. Esse parâmetro será o ID do campo, vindo da classe R. Antes da função findViewById, devemos “forçar” a conversão do seu retorno para o tipo de componente ao qual faz referência. No caso da List e do ArrayAdapter, vamos apenas instanciar a classe, passando os parâmetros padrões.

veiculo = (EditText) findViewById(R.id.veiculo);
salvar = (Button) findViewById(R.id.salvar);
lista = (ListView) findViewById(R.id.lista);
listaCarros = new ArrayList<String>();
adaptador = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, listaCarros);

Para adicionar a ação ao botão, devemos chamar o método setOnClickListener presente na classe Button. Dentro dele, no método onClick(), todas as ações serão definidas. Vamos fazer com que os dados digitados sejam salvos na lista de carros, e exibida no objeto lista.

salvar.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        listaCarros.add(veiculo.getText().toString());
        adaptador.notifyDataSetChanged();
    }
});

Depois de adicionar na lista o texto digitado no campo, devemos chamar o método notifyDataSetChanged() para informar que a lista de carros foi atualizada.

Por fim, não podemos nos esquecer de atrelar o adaptador à lista.

lista.setAdapter(adaptador);

Tudo pronto! Execute o código e veja como ficou.

Como manipular dados de um formulário em Android

Considerações Finais

Esse projeto, até o momento, é bem simples e faz muito pouco perto do que podemos fazer. No próximo tutorial vamos incrementar nossa lista, adicionando mais campos ao formulário.

Baixe o projeto atual aqui.

Até mais, pessoal!

Construindo o Canvas para Aplicativos

Canvas é uma metodologia eficiente que fornece uma visão sistêmica (holística) do negócio, dá direção, mas como um negócio é vivo, certamente mudanças deve fazer parte ao longo do desenvolvimento. Preocupe-se em Startar  a sua ideia!

“Não há um modelo de negócio único… Há realmente uma série de oportunidades e um monte de opções e nós só temos que descobrir todas elas.” Tim O’Reilly, CEO, O’Reilly

Agora vou lhe apresentar os blocos de construção do Canvas. Essa ferramenta se assemelha a tela de um pintor – pré-formatada com os nove blocos – que lhe permite pintar imagens de modelos de negócios novos ou existentes.

“Os empresários não só precisam entender melhor os designers; eles precisam se tornarem designers” Roger Martin, Dean, Rotman School of Management

Utilize sempre blocos adesivos (tipo post-it) que permitem que as ideias sejam adicionadas, movidas e descartadas. Busque em cada um dos 9 blocos a seguir um modelo inovador e que lhe garanta vantagens competitivas.

E não se esqueça que tudo não passa de uma série de hipóteses, então não tenha medo de acrescentar ideias ao quadro.

Os 9 Blocos de Construção do Modelo de Negócio

canvas

Estes blocos cobrem as quatro principais áreas de uma empresa: Clientes, Oferta, Infraestrutura e Viabilidade Financeira.

Segmentos de clientes: O bloco Segmentos de Clientes define os diferentes grupos de pessoas ou organizações que uma empresa pretende alcançar e servir.

Questões:
Para quem estamos criando valor?
Quem são nossos clientes mais importantes?

 

Tipos: Mercado de massa, Nicho de mercado, Segmentados, Diversificados, Plataformas multi-face (ou mercados multi-verso)


Proposições de Valor: Este bloco descreve o pacote de produtos e serviços que criam valor para um segmento de clientes específico.

Questões:

Qual o valor que nós entregamos para o cliente?
Quais os problemas dos nossos clientes que estamos ajudando a resolver?
Quais as necessidades dos clientes que estamos satisfazendo?
Que pacotes de produtos e serviços que estamos oferecendo para cada segmento de clientes?
Quais os diferenciais (características)?

Características: Novidade, Desempenho, Personalização, Fazer as coisas acontecerem, Design, Marca / Status, Preço, Redução de custos, Redução de riscos, Acessibilidade, Conveniência / Usabilidade

 


Canais: O bloco de construção Canais descreve como uma empresa se comunica com e alcança seus segmentos de clientes para oferecer uma Proposta de Valor.

Questões:

Através de que canais que nossos Segmentos de Clientes querem ser alcançados? Como é que vamos alcançá-los agora?

Como os nossos canais estão integrados?
Quais funcionam melhor?
Quais têm o melhor custo-benefício?
Como estamos integrando-os com as rotinas do cliente?

Questões sobre as fases:

Como aumentar a consciência sobre nossos produtos e serviços?
Como podemos ajudar os clientes a avaliar a Proposição de Valor da nossa organização?
Como podemos permitir que os clientes comprem produtos e serviços específicos?
Como é que vamos entregar uma Proposta de Valor para os clientes?
Como fornecer suporte pós-venda ao cliente?

Tipos: Força de vendas, Vendas pela Web, Lojas próprias, Lojas parceiras, Atacadista/Distribuidor

 

Fases: Conscientização, Avaliação, Compra, Entrega, Pós-venda

 


Relacionamento com Clientes: O bloco de construção Relacionamento com Clientes descreve os tipos de relacionamentos que uma empresa estabelece com segmentos específicos de clientes.

Questões:

Que tipo de relação que cada um dos nossos Segmentos de Clientes espera de nós para estabelecer e manter com eles?
Quais estão estabelecidos?
Quanto eles custam?
Como eles são integrados com o resto do nosso modelo de negócio?

Categorias: Assistência pessoal, Assistência pessoal dedicada, Auto-serviço, Serviços automatizados, Comunidades, Co-criação

 


Fontes de Receita: O bloco de construção Fontes de Receita representa o dinheiro que uma empresa gera a partir de cada Segmento de Clientes (custos devem ser subtraídos das receitas para criar lucros).

Questões:

Que valor os nossos clientes estão realmente dispostos a pagar?
Pelo que eles pagam atualmente?
Como eles estão pagando atualmente?
Como é que eles preferem pagar?
Quanto cada Fonte de Receita contribui para as receitas totais?

Tipos: Venda de ativos, Taxa de utilização, Assinaturas, Empréstimo / Locação / Leasing, Licenciamento, Taxas de corretagem, Publicidade

Preço Fixo: Lista de preços, Produto dependente de recurso, Dependente do segmento de clientes, Dependente de volume

Preço Dinâmico: Negociação (barganha), Gerenciamento de produção, Em tempo real de mercado, Leilões

 


Recursos-chave: O bloco de construção Recursos-chave descreve os ativos mais importantes necessários para fazer o modelo de negócio funcionar.

Questões:

Quais Recursos-chave nossas Proposições de Valor, Canais de Distribuição, Relacionamento com Clientes e Fontes de Receita exigem?

Tipos: Físicos, Intelectual, Pessoas, Financeiros

Atividades necessárias: O bloco de construção Atividades-chave descreve as coisas mais importantes que uma empresa deve fazer para seu modelo de negócio funcionar.

Questões:

Quais Atividades-chave nossas Proposições de Valor, Canais de Distribuição, Relacionamento com Clientes e Fontes de Receita exigem?

Categorias: Produção, Resolução de problemas, Plataforma / Rede

 


Parcerias: O bloco de construção Parcerias-chave descreve a rede de fornecedores e parceiros que fazem o modelo de negócio funcionar.

Questões:

Quem são os nossos Parceiros-chave?
Quem são os nossos principais fornecedores?
Que Recursos-chave nós estamos adquirindo dos parceiros?
Quais Atividades-chave os parceiros realizarão?

Tipos: Alianças estratégicas entre não concorrentes, Coopetition: parcerias estratégicas entre concorrentes, Joint ventures para desenvolver novos negócios, Relações fornecedor-comprador para garantir abastecimento confiável

Motivações: Otimização e economia de escala, Redução do risco e incerteza, Aquisição de recursos e atividades especiais

 


Custos: A Estrutura de Custos descreve todos os custos incorridos para operar um modelo de negócio.

Questões:

Quais são os custos mais importantes inerentes ao nosso modelo de negócio?
Quais Recursos-chave que são mais caros?
Que Atividades-chave são mais caras?

Classes: Dirigidos por custos, Baseados em valor

Características: Custos fixos, Custos variáveis, Economias de escala, Economias de escopo

Implementando um leitor QRCode em iOS

Bom pessoal vamos fazer mais um tutorial de objective C hoje vamos criar um leitor de QRCode ( caso você não saiba exatamente o que é um segue um link para dar uma introdução sobre o que são e como funcionam). OK vamos la nosso leitor será algo extremamente simples porem bem legal e não é tão complexo de se fazer, vamos começar com uma singleView.

Em nosso storyboard vamos inserir 1 View, 1 label e por fim 1 botão, nosso tela fica mais ou menos assim:

storyboard

Ainda em nosso storyboard já vamos criar as properties , e também uma ação para nosso botão:

@property (weak, nonatomic) IBOutlet UIView *CapturaDela;

@property (weak, nonatomic) IBOutlet UILabel *status;

@property (weak, nonatomic) IBOutlet UIButton *botaoLerCodigo;

  • (IBAction)lerCodigo:(UIButton *)sender;

Como em nosso projeto vamos precisar acessar alguns dados sobre a câmera, vamos importar a classe AVFoundation caso não tenha sido importada ainda , e importe também o protocolo AVCaptureMetadataOutputObjectsDelegate.

Partindo para nosso .m

Antes de mais nada vamos criar 4 properties dentro de @interface ViewController ()

@property (nonatomic, strong) AVCaptureSession *captureSession;

@property (nonatomic, strong) AVCaptureVideoPreviewLayer *videoPreviewLayer;

@property (nonatomic, strong) AVAudioPlayer *audioPlayer;

@property (nonatomic) BOOL estaLendo;

Essas propertys serão as responsáveis por gravar as imagens, e também trabalham com o áudio.

Feito isso a próxima coisa a se fazer é importar nosso áudio, o beep.mp3 do download está aqui, com o nosso beep já dentro do projeto vamos desenvolver um método para que o som seja pré-carregado e que seja apenas executado quando necessário, vamos então criar nosso método preCarregarBeep, nosso método fica assim:

-(void)preCarregarBeep{

// neste metodo vai fazer o seguite, ele vai deixar nosso beep para ser executado na hora que precisar

// criamos a string que contem o nome do nosso arquivo e sua extensão

NSString *beepFilePath = [[NSBundle mainBundle] pathForResource:@”beep” ofType:@”mp3″];

// criamos agora uma NSURL usando nosso arquivo anterior

NSURL *beepURL = [NSURL URLWithString:beepFilePath];

// vamos fazer um tratamento de erros, caso não tenhamos erro com nosso arquivo vamos deixar nosso beep pronto para ser executado

NSError *error;

_audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:beepURL error:&error];

if (error) {

NSLog(@”Erro ao abrir o som”);

NSLog(@”%@”, [error localizedDescription]);

}

else{

[_audioPlayer prepareToPlay];

}

O próximo método que vamos criar é o comecarALer esse método será disparado quando o usuário clicar no botão para começar a verificar o código.

-(BOOL)comecarALer{

NSError *error;

// criamos nossas instancias de captura de imagem

AVCaptureDevice *captureDevice = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];

AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:captureDevice error:&error];

if (!input) {

// Se acontecer algum erro vai dar um log no erro

NSLog(@”%@”, [error localizedDescription]);

return NO;

}

// inicia a captura de imagem

self.captureSession = [[AVCaptureSession alloc] init];

[self.captureSession addInput:input];

AVCaptureMetadataOutput *captureMetadataOutput = [[AVCaptureMetadataOutput alloc] init];

[self.captureSession addOutput:captureMetadataOutput];

// Create um novo serial dispatch queue.

dispatch_queue_t dispatchQueue;

dispatchQueue = dispatch_queue_create(“myQueue”, NULL);

[captureMetadataOutput setMetadataObjectsDelegate:self queue:dispatchQueue];

[captureMetadataOutput setMetadataObjectTypes:[NSArray arrayWithObject:AVMetadataObjectTypeQRCode]];

//inicia o video preview e atribui ele a nossa view.

_videoPreviewLayer = [[AVCaptureVideoPreviewLayer alloc] initWithSession:_captureSession];

[_videoPreviewLayer setVideoGravity:AVLayerVideoGravityResizeAspectFill];

[_videoPreviewLayer setFrame:self.CapturaDela.layer.bounds];

[self.CapturaDela.layer addSublayer:_videoPreviewLayer];

// começa a captura de tela

[self.captureSession startRunning];

return YES;

}

Criamos um método do tipo booleano pois vamos nos basear na resposta do método para determinar se o código conseguiu ou não executar a leitura.

Bom já temos o método que executa nosso beep, e já temos a leitura do código o que ainda falta? Ainda precisamos que pare a leitura do código afinal se não fecharmos o acesso a camera ela ficaria ainda funcionando, então vamos la vamos criar o método parandoLeitura.

-(void)parandoLeitura{

// para a captura de video

[self.captureSession stopRunning];

self.captureSession = nil;

// Remove o preview do video da view

[self.videoPreviewLayer removeFromSuperlayer];

}

Estamos quase lá aguentem só mais um pouco, vamos ao nosso último método, e esse é o responsável por fazer a mágica, ele realiza a ligação entre o que a câmera está registrando e o que aparecerá na view.

-(void)captureOutput:(AVCaptureOutput *)captureOutput didOutputMetadataObjects:(NSArray *)metadataObjects fromConnection:(AVCaptureConnection *)connection{

// esse metodo é onde “ligamos” nossa camera para fazer a leitura

// checa se o metadataObjects array não é vazio, e que contem ao menos 1 objeto

if (metadataObjects != nil && [metadataObjects count] > 0) {

AVMetadataMachineReadableCodeObject *metadataObj = [metadataObjects objectAtIndex:0];

if ([[metadataObj type] isEqualToString:AVMetadataObjectTypeQRCode]) {

[self.status performSelectorOnMainThread:@selector(setText:) withObject:[metadataObj stringValue] waitUntilDone:NO];

[self performSelectorOnMainThread:@selector(parandoLeitura) withObject:nil waitUntilDone:NO];

[self.botaoLerCodigo performSelectorOnMainThread:@selector(setTitle:) withObject:@”Start!” waitUntilDone:NO];

self.estaLendo = NO;

// lembra do primeiro metodo que criamos, então agora que utilizamo ele

// verifica se nosso audio não for nil executa o som

if (_audioPlayer) {

[_audioPlayer play];

}

}

}

}

Bom pessoal é isso, já temos todos os métodos criados, vamos “chama-los”, lembram da action que criamos no início do projeto dentro dele chamaremos os métodos que acabamos de criar nossa action ficou da seguinte maneira.

– (IBAction)lerCodigo:(UIButton *)sender {

// precisamos primeiramente verificar se nosso usuario já não esta lendo algum código

if (!_estaLendo) {

if ([self comecarALer]) {

self.botaoLerCodigo.enabled = NO;

self.status.text = @”Escaneando código”;

}else{

[self parandoLeitura];

}

}

// inverte o valor de nosso booleano para que nossa action possa ser executa de novo

self.estaLendo = !self.estaLendo;

}

Agora só falta testar o código, lembrando que o código não pode ser testado no simulador pois o simulador não tem camera instalado no simulador faça um teste e tente ler o QRCode abaixo:

qr_code_without_logo

Esse é o link para o download do projeto completo.

Objective-C
Xcode 6.1
iOS 8.1

Layouts XML em Android

Fala galera!

Hoje vamos aprender um pouco sobre layouts XML em Android. Para isso, vamos criar um novo projeto e utilizá-lo em todos os nossos tutoriais seguintes, a fim de criarmos um aplicativo completo.

Seguindo os passos no tutorial anterior (Hello World em Android), vamos criar um projeto chamado Tutorial YESbr, onde a classe principal será chamada ListaCarros.

Layouts XML em Android

Depois de criado, vamos observar a estrutura de diretórios do projeto. Inicialmente, vamos trabalhar apenas com 3 diretórios: src, res/layouts e res/values. No diretório src ficam os arquivos .java dentro dos respectivos pacotes, onde colocamos toda a programação. No diretório res/layouts ficam os arquivos XML dos layouts, e no diretório res/values ficam as constantes do sistema.

Layouts XML em Android

Layouts XML em Android

Vamos começar a edição do layout principal. Abrindo o arquivo activity_main.xml, vamos observar a seguinte estrutura:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:paddingBottom="@dimen/activity_vertical_margin"
   android:paddingLeft="@dimen/activity_horizontal_margin"
   android:paddingRight="@dimen/activity_horizontal_margin"
   android:paddingTop="@dimen/activity_vertical_margin"
   tools:context="br.com.yesbr.tutorial.ListaCarros" >
 
   <TextView
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/hello_world" />
 
</RelativeLayout>

Se você já trabalhou com Swing no Java, fica mais fácil entender a estrutura.

Os layouts são organizados em elementos, representados no código fonte por tags, e são distribuídos de forma hierárquica.

No layout criado automaticamente, podemos observar dois componentes:

  • RelativeLayout: é um container, onde serão adicionados outros componentes. Nesse layout os componentes são “flutuantes”, ou seja, sem alinhamento padrão.
  • TextView: é um elemento de texto. Neste caso, está imprimindo a constante @string/hello_world (mais abaixo vamos falar sobre as constantes).

Inicialmente, vamos apenas modificar nosso layout para o código abaixo. O objetivo do aplicativo é obter a lista de carros que estão/serão cadastrados. Para isso, vamos utilizar quatro elementos:

  • LinearLayout: outro tipo de container, porém neste os elementos são inseridos um após o outro. dependendo da orientação do layout.
  • EditText: uma caixa de texto para inserção de informação.
  • Button: botão que irá executar uma ação.
  • ListView: obtém uma lista previamente submetida.
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:orientation="vertical" >
 
   <EditText
       android:id="@+id/veiculo"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="@string/veiculo" >
 
       <requestFocus />
   </EditText>
 
   <Button
       android:id="@+id/salvar"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/salvar" />
 
   <ListView
       android:id="@+id/lista"
       android:layout_width="match_parent"
       android:layout_height="wrap_content" >
   </ListView>
 
</LinearLayout>

Todos os atributos dos componentes são precedidos por android:, indicando ser um atributo android.

O LinearLayout adota uma orientação vertical, ou seja, os elementos são inseridos um abaixo do outro. layout_width e layout_height indicam largura e altura respectivamente, e foram configurados como fill_parent para preencher toda a área disponível.

EditText nada mais é que um campo de texto (tipo input type=text em HTML). Para ele, definimos o id “veiculo”, pois iremos na programação do projeto. Note que, antes do id, existe um prefixo “@+id/”, que indica o tipo de informação (neste caso, id). Definimos layout_width como match_parent (parecido com full_parent) e layout_height como wrap_content (ajuste de acordo com o conteúdo. O atributo hint é um texto prévio que vem no campo, semelhante ao “placeholder” em HTML. Também foi adicionado uma tag requestFocus dentro da tag EditText, que faz o campo já esteja pronto para digitação.

Button é o botão que irá chamar uma ação, simples assim. Para ele, foi definido o id “salvar”. layout_width e layout_height foram definidos como wrap_content. O texto do botão é definido pelo atributo text, neste caso com a constante @string/salvar.

ListView será identificado pela id lista, e layout_width e layout_height foram definidos como match_parent e wrap_content respectivamente.

Executando o projeto, vamos obter o seguinte resultado:

Layouts XML em Android

Constantes

As constantes são variáveis que não mudam (óoooh). Elas são definidas dentro do diretório res/values quando serão utilizadas em mais de um local, não tendo a necessidade de sempre criar uma por uma. Por padrão, o Eclipse cria três arquivos de constantes: dimens.xml, strings.xml e styles.xml. Pelo nome deles, você com certeza já compreendeu o que cada um deles armazena.

MAS E OS IDs?

Os IDs dos componentes ficam salvos em outro arquivo, a classe R. Essa classe possui todas as referências para os recursos da aplicação. Está localizada no diretório gen/nome_do_pacote, e o próprio Eclipse se encarrega de atualizá-lo quando necessário, e quando o projeto não apresenta nenhum erro. A classe R NUNCA deve ser alterada ou deletada.

Considerações Finais

Por enquanto, nosso projeto não faz o tratamento dos dados. Por enquanto…

Nos próximo post, vamos aprender a tratar os dados e salvar na memória. Não perca!

Baixe o projeto do Eclipse aqui.

DICA: Existe uma ferramenta online, gratuita, para edição de arquivos de layout XML em Android. É o DroidDraw.

Até mais!

Monte o seu APP com Wireframe

Desenvolvimento com Wireframe

Um wireframe poderia ser nada mais do que um esboço numa folha de papel. Outros “wireframes” são criados digitalmente e são realmente mais como protótipos, com objetos clicáveis ​​e toda a interatividade prevista. O tipo de wireframe que será criado vai depender do que o projeto demanda. Projetos mais complicados provavelmente requerem wireframes mais elaborados, enquanto sites simples pode ter wireframes simples.

Uma vez que um wireframe básico é criado, você pode enviá-lo para outros membros da equipe para análise ou colocá-lo um pouco de lado por 1 ou 2 dias para analisar novamente. Quando estiver satisfeito, é hora de mostrá-lo ao cliente ou, caso não seja o caso de haver um cliente, começar a trabalhar em modelos baseados no wireframe.

Disposição dos Elementos> Desenvolver Wireframe> Feedback> Revisão

Ferramentas para criar wireframes

As ferramentas que você vai usar vão depender de preferência pessoal e dos requisitos do projeto. Não há “melhor” ferramenta para fazer wireframes, mas sim aquela na qual você se sente melhor usando e que funciona melhor para você.

Papel e caneta

Você pode querer usar um lápis para o seu esboço inicial, para que você possa apagar as coisas sem ter que começar de novo. Então, a medida que for finalizando os elementos, pode passar caneta por cima para evitar apagar o que não precisa mais ser apagado.

Programas para Criação de Wireframes

Existem diversos programas para criar wireframes disponíveis no mercado. Alguns são pagos, outros de graça, outros mais completos e alguns nem tanto; mas todos com o objetivo de ajudar na criação de wireframes para facilitar e agilizar o processo de desenvolvimento web.

1. WireFrame

wireframe
Esse wireframe é simples e você pode esboçar na primeira tela sem necessidade de login 😉

2. Mockflow

mockflow

Você pode esboçar 1 projeto por vez, mas pode compartilhar com outros usuários ao mesmo tempo.

3. HotGloo

hotgloo

Outra ferramenta para criação de wireframes que com suporte a colaboração em tempo real.

 

Foco na prototipagem e colaboração, os membros da equipe podem rever o trabalho e fornecer feedback em tempo útil, ideias e sugestões em wireframes clicáveis ou conteúdo criativo.

Modelos para Wireframes

Usar modelos (templates) para criar seus wireframes pode acelerar bastante o processo, especialmente se você optar por usar caneta e papel ou programas que são capazer de cumprir este propósito (como o Adobe Illustrator). Veja alguns bons modelos, kits e elementos de interface gratuitos para serem usados na elaboração de wireframes:

  • Free Web UI Wireframe Kit. Fuel You Interface oferece, neste kit, diversos elementos para wireframes, tais como botões, breadcrumbs, caixas de diálogo, campos de busca e mais.
  • Yahoo! Developer Network Design Stencils. Conhecidíssimo set de UI da Yahoo! para o desenvolvimento de wireframes. Eles disponibilizam os modelos para vários programas como OmniGraffle, Visio, Illustrator e Photoshop.
  • Free Sketching & Wireframing Kit. Conjunto de elementos para wireframe disponível em vários formatos de arquivo: Adobe Illustrator, SVG, PDF e EPS.
  • Sqetch. Kit para Illustrator que inclui modelos e elementos, incluindo para iPad, elementos GUI e elementos de formulário.
  • Dragnet Kit for Fireworks. Kit para Adobe Fireworks que inclui uma variedade de elementos da interface como botões, menus, combobox e abas.

Insipire-se

  • I ♥ Wireframes Flickr Group. Milhares de wireframes para se ver e milhares de membros cadastrados colocando novos conteúdos com frequência.
  • I ♥ Wireframes Tumblr. Excelente lugar para se ver muitos wireframes e se inspirar (é associado ao grupo do Flickr acima).
  • Wireframe Showcase. Site que apresenta um “antes e depois”, mostrando wireframes com seus respectivos projetos finais. Excelente!
  • Wireframes Magazine. Cobre todas as coisas relacionadas a wireframe, incluindo toneladas de stencils e modelos, bem como exemplos para inspiração.

 

Wireframe> Mockup>Protótipo certo?
Confira o post “UI Kit Design para Desenvolvimento iOS e Android”

Plist para iOS o que é e como funciona

Bom pessoal vamos fazer um post hoje sobre um tema que irá ajudar muito especialmente para aqueles que estão começando a programar, o uso de plists é bem interessante especialmente para aqueles que precisam de uma maneira fácil de salvar os dados do aplicativo de maneira extremamente simples rápida e fácil.

Mas antes de tudo vamos definir o que é uma plist, imagine a seguinte situação quando vamos salvar dados em arquivo de texto, apenas para ter os dados salvos, uma plist é como se fossemos salvar em um txt, porem o plist é diferente de um arquivo de texto é um array, simples assim. Isso claro é um definição simplista do que é.

Mas e quais as vantagens de se usar uma plist ao invés de usar CoreData ou SqLite ?

A maior vantagem é sua praticidade, é muito mais simples salvar os dados em plist e recuperar eles porém tem suas desvantagens, fica muito mais simples para um usuário acessar os dados salvos dessa maneira, e em projetos grandes é recomendável usar o CoreData ou SqLite, porem para projetos menores plists são ferramentas a se considerar.

Devidas explicações dadas vamos ao código.

Vamos criar um novo projeto simples vamos só salvar os dados no dispositivo e recuperar os dados, apenas para diminuir o trabalho não vamos criar um Single View vamos criar uma tabbed que tem duas telas, fizemos isso apenas para economizar um pouco de tempo.

imagem1

nossa primeira tela vamos colocar apenas um campo texto para o usuário digitar o que ele quer salvar e um botão salvar.

imagem2

e nossa segunda tela vamos apenas colocar um campo de texto, onde vamos mostrar os dados inserido pelo usuário na primeira tela.

imagem3

Vamos a codificação na nossa classe FirstViewController vamos fazer a maior parte do código no primeiro momento vamos apenas criar um array e iniciar colocar um ação para nosso botão. Essa ação será a maior do nosso projeto em nosso viewDidLoad iniciamos o array criado, nosso action inicia inserindo um novo dado no array:

[dadosParaSalvar addObject:self.campoTexto.text];

Agora com precisamos salvar nosso array em algum lugar, o ideal seria salvar o array na mesma pasta do aplicativo, ou seja precisamos definir onde está nosso app.

Vamos precisar de três variáveis do tipo string:

//abre o caminho para a home do dispositivo

NSString *caminhoParaHome;

// arquivo que contem o caminho para a pasta Documents do app

NSString *caminhoParaDocuments;

// nessa variavel salvamos o nome de nosso arquivo completo

NSString *caminhoParaMeuArquivoSalvo;

Vamos usar essas variáveis para definir onde vamos salvar, o que vamos salvar e o caminho para a pasta home do app.

Basicamente vamos precisar dessas três linhas de código:

// acessa a pasta Home do app

caminhoParaHome = NSHomeDirectory();

// acessa a pasta Documents dentro da home do app

caminhoParaDocuments = [caminhoParaHome stringByAppendingPathComponent:@”Documents”];

// acessa a pasta do app, e cria o arquivo meusDados,plist

caminhoParaMeuArquivoSalvo = [caminhoParaDocuments stringByAppendingPathComponent:@”meusDados.plist”];

Agora temos todos os caminhos para salvar nossa plist, precisamos salvar ela, para isso vamos usar a seguinte linha de código:

[dadosParaSalvar writeToFile:caminhoParaMeuArquivoSalvo atomically:YES];

E pronto basicamente salvamos os dados do nosso array já serão salvos em nosso dispositivo, e para mostrar o caminho do nosso arquivo precisamos só dar um log em nossa variável caminhoParaDocuments.

Ok já temos um sistema para salvar os dados, (lembrando que os dados serão substituídos a cada vez que você salvar) agora precisamos retornar esses dados para nosso aplicativo.

Em nossa SecondViewController vamos precisar de um outlet para nosso campo de texto e um array para salvar o retorno.

Com ambos declarados e iniciados, usamos basicamente o mesmo código a tela anterior, porém mudamos a última linha, pois não precisamos salvar mais os dados, e sim retornar os que já estão salvos, vamos apenas copiar e colar nossa linhas da action que criamos para salvar os dados, mas a última linha vai mudar, nosso viewDidLoad da segunda tela fica da seguinte maneira:

arrayRetornado =[[NSMutableArray alloc]init];

//abre o caminho para a home do dispositivo

NSString *caminhoParaHome;

// arquivo que contem o caminho para a pasta Documents do app

NSString *caminhoParaDocuments;

// nessa variavel salvamos o nome de nosso arquivo completo

NSString *caminhoParaMeuArquivoSalvo;

caminhoParaHome = NSHomeDirectory();

caminhoParaDocuments = [caminhoParaHome stringByAppendingPathComponent:@”Documents”];

caminhoParaMeuArquivoSalvo = [caminhoParaDocuments stringByAppendingPathComponent:@”meusDados.plist”];

// retorna o que estiver salvo dentro do arquivo se selecionamos

arrayRetornado = [NSMutableArray arrayWithContentsOfFile:caminhoParaMeuArquivoSalvo];

self.campoTexto.text = [NSString stringWithFormat:@”%@”,arrayRetornado];

Basicamente a única diferença entre os dois códigos está na última linha em um nós salvamos os dados e no outro nós retornamos, agora podemos fazer um teste simples, abra o aplicativo e salve alguma frase, vá para a segunda tela e veja se ela está aparecendo la, caso ela já esteja la feche e reabra o app, vá direto a segunda tela a frase ainda deve estar sendo mostrada la.

Bom pessoal por hoje é isso o link para o download do projeto completo SalvandoPlist , espero ter ajudado.

Quais as linguagens de programação mobile mais utilizadas

Hoje em dia com tantas opções de linguagens de programação, sistemas operacionais e plataformas sempre bate a dúvida: estou no caminho certo? Ou ainda: em qual linguagem devo investir meu tempo e dinheiro?

Quais as linguagens de programação mobile mais utilizadas?

Naturalmente a resposta não é fácil, porém podemos vislumbrar o futuro a partir de dados atuais a respeito do volume de pessoas que programa (que normalmente levam a uma comunidade mais forte) e as que utilizam (levando a um maior market share).

Como sempre, vamos por partes:

Quais as linguagens de programação mais comentadas, utilizadas e/ou mais populares na internet, como saber?

Existem vários sites que fazem esta “média” baseando-se em diversos sistemas de controle como por exemplo número de buscas no Google, abertura de cursos, fóruns, comentários, entre outros. Dois que mais utilizamos para ter uma base são: http://www.tiobe.com e https://sites.google.com/site/pydatalog/pypl/PyPL-PopularitY-of-Programming-Language, veja abaixo os gráficos comparativos deles:

linguagens-de-programacao-mobile-mais-utilizadas-pypl linguagens-de-programacao-mobile-mais-utilizadas-tiobe

 

linguagens-de-programacao-mobile-mais-utilizadas-pypl-graficos linguagens-de-programacao-mobile-mais-utilizadas-tiobe-graficos

Com estes gráficos podemos aferir algumas situações tais como:

1- No último ano as modificações foram pequenas, como uma pequena queda do C++, PHP e Javascript.

2- O “início” da linguagem Swift que foi anunciada este ano pela Apple e um grande volume de programadores Objective-c migrarão aos poucos para esta nova linguagem.

3- Linguagens como Perl tiveram uma queda acentuada possivelmente por migração de alguns programadores para outras linguagens bem como a menor entrada de novos programadores.

4- O Java continua sendo uma das linguagens mais utilizadas juntamente com C/C++ por serem linguagem fortemente utilizadas por empresas e sua robustez, bem como possível utilização para mobile também.

 

Blz, isso me dá uma ideia geral e posso acompanhar o avanço das linguagens mais utilizadas. Mas quero mais, como posso acompanhar mais de perto com exemplos e tutoriais?

Como sempre, nosso amigos Google dará uma excelente ajuda em conjunto com o Facebook e Google+. No Google poderá buscar exemplos, tutoriais e fóruns para discutir e ficar cada vez mais por dentro da linguagem escolhida.

O Facebook e o Google+ colaboram muito  ao se engajar em grupos específicos de programação para poderem debater e trocar experiências de uma forma mais dinâmica.

Utilizar RSS é uma boa opção para sites que possuam esta funcionalidade ativa pois te mantém dentro do círculo com pouco ou nenhum esforço.

É essencial saber pelo menos o básico do inglês para não se perder em traduções do Google Translate que às vezes pisa na bola com vontade, então cuidado, sempre que possível treine seu inglês pois existe um volume muito maior de material visto o volume de programadores.

 

No geral, as mais utilizadas são Java e Objective-c que cobrem a maioria do market share de aparelhos vendidos no mundo. Porém não quer dizer que sejam melhores que as outras, somente quer dizer que tem mais pessoas utilizando, comentando, postando etc sobre estas linguagens, afinal como já disseram há muito tempo: “A melhor linguagem de programação para você é a que você sabe usar bem”.