Minicurso de Android no V Workshop Tocantinense de Sistemas de Informação Católica-TO

Para os alunos e interessados no conteúdo disponibilizado durante o mini curso, coloco aqui os recursos utilizados.

Android Básico

Baixe a apresentação aqui: Apresentação

Baixe as imagens aqui: Imagens

Baixe o código aqui: Código

Publicado em Android

Rails migrations tasks

Hoje vou passar uma lista de tarefas rake para manipulação de sua base de dados

  • db:create cria a base de dados do env atual
  • db:create:all cria databases de todos os envs
  • db:drop apaga a base de dados do env atual
  • db:drop:all apaga todas as base de dados de todos os envs
  • db:migrate executa as migrações que ainda não foram executadas ainda
  • db:migrate:up roda uma migration específica
  • db:migrate:down retrocede para uma migration específica
  • db:migrate:status exibe o estado da migração atual
  • db:migrate:rollback retrocede para a última migration
  • db:forward avança a versão atual do schema em um.
  • db:seed roda o arquivo db/seeds.rb
  • db:schema:load carrega o schema para a base de dados do env atual
  • db:schema:dump da um dumps no schema do env atual
  • db:setup roda o db:schema:load, db:seed
  • db:reset roda db:drop db:setup
  • db:migrate:redo roda (db:migrate:down db:migrate:up) or (db:migrate:rollback db:migrate:migrate) dependendo da migração
  • db:migrate:reset roda db:drop db:create db:migrate
  • db:migrate VERSION=0 retrocede todos os migrations
Publicado em Ruby

Android: Networking

Uma das características que definem os sistemas móveis modernos é que eles podem nos manter conectado e em rede, sem nos prender a um local. Nesta lição, vamos explorar as práticas que você precisa para conectar seus aplicativos na internet. Então, eu vou começar esta lição, discutindo redes em geral.

Essa discussão se concentrará em conectar suas aplicações a internet usando Hypertext Transfer Protocol ou HTTP especificamente usando solicitações HTTP GET. Depois disso, vou apresentar várias classes que o Android oferece para apoiar este tipo de conectividade. E, finalmente, eu vou discutir como suas aplicações podem processar os dados recebidos em resposta a essas solicitações HTTP GET. Em particular, eu vou falar de dois formatos populares de dados. Um deles, o Javascript Object Notation Language, ou JSON.

O outro é o Extensible Markup Language, ou XML. E eu vou falar sobre como você analisar, e processar essas respostas HTTP quando elas forem formatadas em um desses formatos. Assim, nossos dispositivos nós darão essa mobilidade.

Dispositivos de hoje combinam poderosos processadores com conexões de rede Wi-Fi mais rápidas e redes móveis. Aplicações portáteis, portanto, muitas vezes querem fazer uso desses recursos de rede para acessar e fornecer dados e serviços. Agora, para ajudá-lo a fazer isso, Android inclui uma variedade de classes de suporte incluindo Socket e URL, no pacote Java.net, as classes HttpRequest e HttpResponse nos pacotes org.apache.

E as classes URI, AndroidHttpClient e AudioStream, nos pacotes android.net. Nesta lição nós vamos olhar para várias dessas classes usando cada uma delas para implementar o mesmo aplicativo de exemplo. E este aplicativo interage com um serviço de internet para obter informações sobre os terremotos que ocorreram em uma região geográfica específica. E como você vai ver, que os dados são retornados em vários formatos.

Mais tarde, na aula, eu vou mostrar-lhe como processar os dados para extrair apenas a informação que você deseja. Ah, e, e uma outra coisa. Como você verá em um segundo, esses dados incluem informação geográfica, eles estão realmente implorando para ser exibido em um mapa, e não em texto. Agora, nós não vamos fazer isso nesta lição, mas mantenha isso em mente, porque nós vamos voltar a isto, quando chegarmos à lição em mapas e localização.

Portanto, a fim de fazer o trabalho do aplicativo, o código precisa criar uma solicitação HTTP, enviá-lo a um servidor, recuperar os resultados e, em seguida, exibi-los. Android fornece várias classes para te ajudar com isso. Três falaremos agora são a classe Socket, a classe HttpURLConnection e o AndroidHttpClient.

Exemplo: Ao pressionar um botão, o aplicativo irá emitir uma solicitação HTTP GET para um servidor externo. E esse servidor irá responder com um texto complexo que contém os dados do terremoto solicitados.

E então, este código continua obtendo fluxo de entrada do socket e passando-a para um método chamado readStream. O método readStream última instância lê os dados de resposta do InputStream do socket.

E, em seguida, retorna a resposta como uma única seqüência. E essa string é passado para o método OnPostExecute que executa no thread principal e que exibe a resposta na exibição de texto. Se voltar para o aplicativo, você notará que o texto de resposta inclui não apenas os dados do terremoto, mas também os cabeçalhos de resposta HTTP. Agora normalmente, eu não gostaria de exibir esse texto aqui.

Eu realmente só quero te mostrar os dados do terremoto. Assim, no caso, eu deveria ter analisado a resposta e tirou apenas os dados que eu queria. Além disso, você deve ter notado que eu não escrevi nada do código de tratamento de erro que você realmente precisa para fazer esta aplicação robusta. E estes pontos, capturar muito bem os trade-offs de usar soquetes.

O nível muito baixo, você pode escrever o que quiser sobre o soquete, mas, em troca, você tem que lidar com todos os muitos detalhes de fazer as solicitações HTTP, todo o tratamento de erros, e todo o processamento das respostas HTTP. O próximo implementação veremos usa a classe HttpURLConnection.  A terceira classe é cliente HTTP Android. Esta classe é uma implementação do DefaultHttpClient do projeto Apache e permite que uma grande quantidade de personalização.

Em particular, a classe de quebra de uma transacção HTTP para um objecto de pedido e resposta para um objecto. Assim você pode criar subclasses que personalizam o tratamento de solicitações e suas respostas.

 

Serie: 5 – 8 – Networking – Part 1

Publicado em Android

Android: Alarmes

AndroidIconMaker0001

 

Os exemplos de aplicações estudamos até agora tomaram decisões e, em seguida, realizaram algo. Mas se o seu aplicativo tiver que toma uma decisão, mas a ação a ser realizada só será executada daqui a 5 horas, ou amanhã à meia-noite, ou a cada 15 minutos? Nesse caso, será necessáruo criar e definir alarmes para o aplicativo. Nesta lição, eu vou começar por discutir o que os alarmes são e como eles são usados.

Em seguida, vou discutir o Android AlarmManager e as APIs que ele oferece para a definir e cancelar os alarmes. Depois disso, vou discutir os vários tipos de alarmes que o Android suporta. E, finalmente, eu vou apresentar e discutir um exemplo de aplicação que utiliza alarmes. Agora, em poucas palavras, os alarmes são um mecanismo para o envio de intents em algum ponto, ou pontos, no futuro.

E isso é útil, pois permite que um aplicativo execute algum outro código para realizar alguma ação, mesmo quando o aplicativo não está sendo executado. Uma vez que os alarmes foram criados e registrados, eles são mantidos e monitorados, mesmo que o dispositivo vá “dormir”.

E como nós vamos falar mais tarde, dependendo de como você configure um alarme, se o dispositivo estiver inativo, ele poderá ser iniciado pelo alarme para executar alguma coisa ou o alarme pode ser retido até que a próxima vez que o dispositivo estiver ativo. E alarmes continuará ativo até que o dispositivo seja desligado.

No encerramento, todos os alarmes registrados serão cancelados. Para dar-lhe alguns exemplos de alarmes, uma dia desses mexendo em alguns códigos fonte do Android e me deparei com vários aplicativos que usam alarmes. Por exemplo, o aplicativo de mensagens MMS usa alarmes para iniciar um serviço que pode encontrar mensagens MMS que não foram enviadas e pode tentar envia-las novamente.

O aplicativo Configurações do Android pode tornar o dispositivo detectável através de Bluetooth. E quando se faz isso, a aplicação define um alarme, e quando o alarme dispara, o aplicativo faz com que o dispositivo não seja mais detectável. E a aplicação do telefone mantém um cache de informações do usuário.

Esta aplicação utiliza alarmes para atualizar periodicamente o cache. Se você quiser usar alarmes em seus próprios aplicativos, você fazê-lo através da interação com o serviço AlarmManager. Para obter uma referência a este serviço, você chama o o Context da classe GetSystemService, passando o nome do serviço, neste caso, alarm_Service como parâmetro.

Uma vez que você tem uma referência para o AlarmManager, você pode usar alguns de seus métodos para criar e definir alarmes. Por exemplo, você pode usar o método Set para definir um único alarme. E este método tem três parâmetros.

Um tipo, que vamos discutir em breve, que representa o momento em que o alarme deve ser desativado e uma PeningIntent, que encapsula a operação que deve ocorrer quando o alarme finalmente ficar inativo.

Você pode usar esse método, setRepeating, para definir se um alarme que vai ser executado repetidamente em intervalos específicos. Este método tem quatro parâmetros, três deles vimos no método Set, mais um long adicional que especifica a quantidade de tempo entre cada execução do alarme.

Outro método é AlarmManager setInexactRepeating. Este método é semelhante ao setRepeating, em que o alarme deve inativo periodicamente, mas este método dá Android mais flexibilidade para decidir exatamente quando disparar os alarmes.

Por exemplo, o Android pode lote vários alarmes desse tipo e executa-los, ao mesmo tempo, para não ficar ativando o dispositivo muitas vezes. E se você quer ter este tipo de comportamento, então o seu intervalo de tempo deve ser uma das seguintes constantes, que especifica intervalos de 15 minutos, 30 minutos, uma hora, 12 horas ou 24 horas.

E se você não usar uma dessas constantes, então o comportamento dos alarmes irão ser os mesmos que se você tivesse utilizado o setRepeating. Cada um dos três métodos que acabei de mostrar possuem um parâmetro chamado Type. Vamos falar sobre os tipos de alarme agora.

Android proporciona dois graus de capacidade de configuração em relação aos alarmes. Um deles tem a ver com a forma com que o tempo informado é interpretado, e o outro diz Android como responder caso o dispositivo esteja inativo quando o alarme disparar. Vejamos cada um deles. Primeiro, você se lembra que cada um dos métodos de configuração de alarme levou um long como parâmetro, e eu disse que esse long representa um periodo.

Alarmes do Android podem interpretar este valor long de duas maneiras diferentes. Uma delas, é que podemos considerá-lo como se fosse um relógio e, neste caso, o long, representa o número de milissegundos desde a meia-noite do dia 1 de janeiro de 1970.

E dois, pode ser interpretado como um tempo adicional ao relógio do sistema, ou seja, a quantidade de tempo decorrido desde o momento da última inicialização do sistema. A segunda questão, é o que o Alarme deve fazer quando o dispositivo estiver inativo. Uma possibilidade é para acordar o dispositivo e entregar a intenção.

Outra opção, é deixar o dispositivo continuar inativo, e entregar a intenção na próxima vez que o dispositivo acordar. Assim, temos quatro possibilidades, definidas como vemos a seguir. RTC_WAKEUP. Dispare o alarme no momento especificado (modo relógio).

Se o dispositivo estiver dormindo, acorde-o e entregue a intenção. RTC: dispare o alarme no momento especificado (tipo relógio), mas se o dispositivo estiver dormindo, não acorde-o agora. Em vez disso, entregue a intenção quando o dispositivo estiver próximo de acordar. E há ELAPSED_REALTIME e ELAPSED_REALTIME_WAKEUP.

Para estes dois tipos de alarmes, Android dispara o alarme depois de um tempo determinado tempo que ele foi ligado, e se o dispositivo está dormindo quando o alarme dispara, ele não vai ser acordado com ELAPSED_REALTIME. E Ele vai ser acordado com ELAPSED_REALTIME_WAKEUP.

A última parte das APIs AlarmManager que vamos discutir é o PendingIntent. Um PendingIntent detém uma intenção regular e serve essencialmente como uma permissão, em que um componente permite que um segundo componente use a intenção subjacente, como se fosse o primeiro componente.

Três métodos que podem ser utilizados para criar uma PendingIntent são getActivity, que devolve uma PendingIntent que pode ser utilizado para iniciar uma atividade. GetBroadcast, que retorna uma PendingIntent que pode ser usado para transmitir uma intenção. E getService, que devolve uma PendingIntent que pode ser usado para iniciar um serviço.

Serie: 5 – 7 – Alarms

Publicado em Android

Android: AsyncTasks e Handlers

AndroidIconMaker0003

A próxima classe de suporte de threand que vamos discutir é a classe AsyncTask. Essa classe fornece um quadro geral para a gestão de tarefas, que, como em nossos exemplos anteriores, envolver o trabalho que tem de ser compartilhado entre uma thread no segundo plano e uma UI thread. O fluxo de trabalho geral que você segue quando você está usando uma Async Task, é que o trabalho é dividido entre um background thread e a UI Thread.

A thread em segundo plano executa a operação de longa duração, e pode, opcionalmente, informar o seu progresso. A UI Thread, por outro lado, é responsável pela configuração inicial da operação de longa duração. Ela é responsável pela publicação de informações sobre o andamento parcial da thread que está em segundo plano, e é responsável por completar a operação após essa thread terminar o seu trabalho.

AsyncTask é uma classe genérica. Leva três tipos de parâmetros, Params, Progress, e Result. Params é o tipo dos parâmetros que são de entrada para os As-, ao AsyncTask. Progress é o tipo de quaisquer relatórios intermediários, e o resultado é o tipo de resultado que é calculado pela tarefa assíncrona. O fluxo de trabalho de uma AssyncTask é o seguinte, em primeiro lugar, o método OnPreExecute() é executado na UI thread do usuário antes que o método doInBackground inicie.

OnPreExecute normalmente irá configurar a operação de longa duração. Depois disso, o método doInBackground realiza a maior parte da operação em segundo plano. E este método recebe uma lista variável de parâmetros de entrada e retorna um resultado do tipo de Result. Agora, enquanto doInBackground está rodando, ele pode, opcionalmente, chamar o método publishProgress, passando em uma lista de variáveis ​​de valores que supostamente fornecem alguma indicação do andamento as operações em execução. Se a background thread faz chamadas para publishProgress, então algumas chamadas para onProgressUpdate normalmente seria feita na UI Interface do usuário, enquanto a thread de segundo plano ainda está em execução.

E, finalmente, OnPostExecute será chamado na UI Thread do usuário com o resultado retornado pela background thread. Vamos olhar para uma versão do nosso aplicativo LoadIcon implementado com uma AsyncTask.

A última coisa que eu quero falar nesta lição é a classe Handler. Como a AsyncTask, a classe Handler é projetado para trabalhar entre as duas threads.

A classe Handler é mais flexível, no entanto, em que ele vai trabalhar em conjunto com qualquer uma das duas threads, e não apenas para uma background thread ou uma UI Thread. A Handler está associado com uma thread específica. Um thread pode entregar o trabalho para outro thread, enviando mensagens ou postando Runnables para um Handler que está associado a essa outra thread. Então, primeiro, vamos discutir mensagens e Runnables, e depois nós vamos entrar na arquitetura da própria classe Handler.

Agora, você já sabe sobre Runnables. Você pode usar eles quando o remetente sabe exatamente o que as etapas de trabalho a serem realizadas, mas quer que o trabalho realizado na thread do Handler. Uma mensagem, por outro lado, é de uma classe que pode conter dados como um código de mensagem, um objecto de dados qualuqer, e alguns valores inteiros.

E você usa mensagens quando a thread remetente quer indicar uma operação que deve ser feita em outra thread, mas deixa a implementação dessa operação para a própria Handler. Então, agora vamos falar sobre como Handlers de usam essas mensagens e Runnables. Cada segmento Android está associada a um MessageQueue e um Looper.

O MessageQueue é uma estrutura de dados. Ele contém mensagens e Runnables. O Looper leva essas mensagens e Runnables para fora do MessageQueue e os despacha de forma apropriada. Agora, este gráfico descreve uma thread que criou um executável. E isso tem usado um objeto Handler de publicar esse runnable para thread do Handler. Quando thread A faz isso, um runnable é colocado no MessageQueue da thread associada ao Handler.

Agora algo muito semelhante acontece com as mensagens. E este gráfico descreve um thread B, que criou uma mensagem, e que é associada com um Handler, então método sendMessage manipulador enviar essa mensagem para thread do Handler. Quando segmento B faz isso, a mensagem é colocada na MessageQueue associado a esse Handler. Agora, enquanto tudo isso está acontecendo, o objeto Looper está sentado lá, apenas esperando o trabalho aparecer na MessageQueue.

E quando esse trabalho for exibido, o Looper reage de uma de duas maneiras, dependendo do tipo de trabalho que acaba de chegar. Se esse trabalho é uma mensagem, o Looper vai lidar com a mensagem chamando o método handleMessage do Handler, e passando a mensagem em si. Se em vez disso, que o trabalho é um runnable, então o Looper vai lidar com isso simplesmente executando esse runnable.

Agora, aqui estão alguns dos métodos que você usa ao postar Runnables a um Handler. Nós já vimos o método post, há uma série de outros métodos que permitem que você agendar o trabalho para execução em momentos diferentes. Por exemplo, você pode usar o método postAtTime para adicionar um runnable em uma MessageQueue, mas para executá-lo em um determinado momento.

Há também um método postDelayed, e que permite que você adicione um runnable a um MessageQueue, mas para executá-lo depois de um tempo especificado. Se você quiser enviar mensagens, você precisa primeiro criar a mensagem. Uma maneira de fazer isso é usar o método ObtainMessage do Handler, que lhe dá uma mensagem com o Handler já definido.

Você também pode usar o método de obtenção da classe de mensagem. E uma vez que você tem a mensagem, você vai querer definir os dados para a mensagem. Há uma série de variações para fazer isso por favor, confira a documentação. Tal como acontece com Runnables, há um certo número de métodos que podem ser utilizados para enviar a mensagem. Não é o método sendMessage que nós acabamos de falar.

Há também uma versão que permite que você coloque a mensagem na frente do MessageQueue para tê-lo executar o mais rápido possível. Há um método sendMessageAtTime que adiciona a mensagem à fila, de acordo com o tempo especificado. Há também um método sendMessageDelayed que enfileira a mensagem no momento atual, mais o atraso especificado.

 

Serie: Android: 5 – 6 – Thread, AsyncTasks e Handlers parte 2

Publicado em Android

Incríveis temas grátis para Bootstrap

 

Kit grátis de ciração de UI do Bootstrap para qualquer desenvolvedor que queria criar incríveis e funcionais temas para seu website.

Arctic Sunset

ScreenShot

Leia mais ›

Publicado em Design

Solving problem in Android Admob onFailedToReceiveAd(Invalid Google Ad request.)

AndroidIconMaker0001

 

 

 

 

 

 

 

IDE: Android Studio 0.3.5

android:minSdkVersion=”7″

android:targetSdkVersion=”19″

GoogleAdMobAdsSdk 6.4.1

Error: 10-07 07:54:00.693    2588-2588/package I/Ads﹕ onFailedToReceiveAd(Invalid Ad request.)

Leia mais ›

Publicado em Android

Teste seu HTML+CSS+Javascript Online

jsfiddle-logo1

 

 

 

 

 

 

 

 

 

 

JSFIDDLE: Esta ferramenta online permite que você copie e cole seu código HTML, CSS e JavaScript, gerando o resultado instantaneamente, e permitindo o compartilhamento do resultado por URLs.

Basta acessar: http://jsfiddle.net/

Publicado em Dicas

Como converter Videos do Vine para GIF facilmente

Converter Vine para GIF

 

 

 

Quem gosta do Vine sabe o quão bom seria poder transformar aqueles pequenos videos do Vine ( que está em um Player Flash) em animações GIFs de boa qualidade e poder fazer o que quiser com eles, como postar no Google Plus, Facebook, ou sei lá o que a imaginação de vocês criam.

Mas saibam que esse processo existe e é absolutamente simples de fazer:

  • Acessem: http://www.gifvine.co/
  • Peguem a URL da imagem Vine de vocês (por exemplo https://vine.co/v/b3v5h3Piwt7 )
  • Insiram no Site
  • Cliquem no botão “Make this Vine a Gif” (ou faça desse Vine um GIF)
  • Pronto agora basta salvar seu GIF e fazer o que quiser :)
Marcado com:
Publicado em Dicas

Padrões de Design para Icones da Google – Parte 2

Marca da Google é formada de várias maneiras, uma deles é a manutenção da coerência visual dos ativos visuais.

Em janeiro de 2012, a expansão sobre novos estilos de iconografia foi realizado por seu laboratório criativo, começaram a criar este sólido, mas flexível, conjunto de diretrizes que têm ajudado os designers e fornecedores do Google a produzir um trabalho de alta qualidade, o que ajuda a fortalecer a identidade do Google.

O que você vê aqui é um resumo visual das diretrizes, divididas em dois projetos pela Behance:

Google design style:Executive Creative Director: Chris Wiggins
Senior Graphic Designers: Jesse Kaczmarek, Nicholas Jitkoff, Jonathan LeeGuideline design:Art Director / Team Manager: Christopher Bettig
Senior Graphic Designer / Project lead: Roger Oddone
Designers: Alex Griendling, Christopher Bettig, Jefferson Cheng, Roger Oddone, Yan Yan, Zachary Gibson
Contributors: Web Studio, Brand Team, Creative Lab



Parte 1: http://www.redrails.com.br/?p=2023

Related Posts Plugin for WordPress, Blogger...
Publicado em Design