Uma coleção de piadas selecionadas para sorrir e para fazer seus amigos sorrirem junto. Faça um amigo rir e será lembrado sempre.

Sabe aquele amigo de faculdade, aquele amigo da escola ou aquela turma que você se divertia muito? a quanto tempo você não se comunica com eles? Hora de dar uma aparecida em? que tal mandar aquela mensagem engraçada para puxar um assunto… a não sabe nenhuma ou tem maior preguiça de escrever usando seu aparelho?
Seus problemas acabaram, construímos esse programinha para você. Basta escolher a piada clicar e pronto pode manda-la para quem quiser. Fácil não?
Então não perca tempo baixe agora!

Link para download: https://market.android.com/details?id=br.com.redrails.piadas

Create Android Icons in All Basic Resolutions

With this program is possible generate and resize icons in 8 different resolutions with one click.

Table 1. Summary of finished icon dimensions for each of the three generalized screen densities, by icon type.

Font: Android Icon Design Guidelines

Download Android Icon Maker (2459)

Desenvolvendo um pequeno aplicativo aqui que logo mais posto no blog me deparei com um problema que acabou de dando um pouco de dor de cabeça. Para livra-los desse incômodo trago aqui uma solução bem simples.

No Netbeans quando cria-se uma Aplicação Desktop existe no projeto um esquema bem legal de resources, vou-lhes mostrar como utiliza-lo.


Bom meu problema é simples queria coloca um ícone na janela da aplicação e que por consequência fica também na barra de tarefas, assim:

Ok conseguia coloca o ícone utilizando várias técnicas achadas por ai, mas um problema surgia ao tentar distribuir (dist) o jar. A solução já estava ali só era necessário utiliza-la. Vamos lá:
Primeiro coloque seu ícone (em nosso ex icon.png )na pasta resources (PROJETO/src/PACOTE/resources)

Feito isso encontre o arquivo de propriedades seu JFrame principal (no meu caso AndroidIconMakerView.properties)

Adicione a linha de propriedades

windowIcon.icon=icon.png

Feito isso sobra a “difícil” parte da codificação, assim:

        getFrame().setIconImage(resourceMap.getImageIcon("windowIcon.icon").getImage());

Gostaram?

Implementação do sistema de sondagem de sinal

Para realizarmos um ping no Android precisamos executar chamadas em recursos do sistema através de métodos presentes no Java, já que esse recurso não está presente na API do sistema da Google. Um problema na realização dessa técnica para executar o PING é que ela necessita de permissões de super usuário para ser realizada em um

Para realizar um ping no java, podemos utilizar o método Runtime.getRuntime().exec(); que realiza uma chamada no sistema, permitindo executar comandos como se estivessemos no console do sistema operacional. O problema desse procedimento é que o executável ping (/system/bin/ping) está limitado para usuários normais (figura 1), essa limitação permite que o ping serja feito apenas em endereço local (figura 2). Dessa maneira necessitamos de acesso de super usuário para que possamos realizar o ping sem tal empecilho.

O processo de conceder acesso de super usuário (root) para um dispositivo é conhecido como rootear. um dispositivo rooteado (rooted) permite que usuários comuns executem ações de super usuário no dispositivo. Podemos rootear um dispositivo através de modificações no SO obtidas com por exemplos outros aplicativos que realizam esse processo.

Em nosso exemplo utilizaremos um aplicativo chamado Superuser (https://market.android.com/details?id=com.noshufou.android.su) para auxilio no gerenciamento de permissões do Android

Abaixo a descrição da classe necessária para execução como super usuário.

package br.com.redrails;
/*
 * Luiz Carvalho
 * @LuizCarvalho
 * luizcarvalho@redrails.com.br
 * www.redrails.com.br
 * http://br.linkedin.com/in/luizkarvalho (recommend me)
 * more in http://www.redrails.com.br/tags/QoV/
 * */

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

public class SuDroid {
	// private static final String TAG = "sudroid";

	public String success_msg = null;
	public String error_msg = null;
	public Boolean success = false;

	public SuDroid(String command) {
		Process proc = run(command);

		try {

			if (proc.waitFor() == 0)
				success = true;

			success_msg = getResult(proc.getInputStream());
			error_msg = getResult(proc.getErrorStream());

		} catch (InterruptedException ex) {
			success = false;
			print("Error in execute command: " + ex.toString());
		} catch (NullPointerException ex) {
			success = false;
			print("Error in execute command:  " + ex.toString());
		}

	}

	public String result() {
		return "";
	}

	public Process run(String command) {
		Process proc = null;
		try {
			proc = Runtime.getRuntime().exec("sudo");
			DataOutputStream dataProc = new DataOutputStream(proc.getOutputStream());
			dataProc.writeBytes("exec " + command + "\n");
			dataProc.flush();
		} catch (Exception ex) {
			print(ex.getMessage());
			success = false;
			proc = null;
		}
		return proc;
	}

	private String getResult(InputStream istream) {
		String line = null;
		StringBuffer result = new StringBuffer();
		BufferedReader dataIstream = new BufferedReader(new InputStreamReader(
				istream));

		try {
			while ((line = dataIstream.readLine()) != null) {
				result.append(line + "\n");
			}
			dataIstream.close();
		} catch (Exception ex) {
			success = false;
			print(ex.getMessage());
		}

		if (result != null) {
			return result.toString();
		} else
			return null;

	}

	public void print(String msg) {
		System.out.println(msg);
		// Log.e(TAG, "A Error Occurred: " + e.toString());
	}

}

Essa técnica pode ser usada para desenhar em qualquer* linguagem ou componente do Google Earth, mas para melhor entendimento vamos pegar o desenho de polígonos utilizando Ruby.

Primeiro vamos entender sobre os arquivos de entrada e saída:

KML Estrutura XML composta pelas descrições de cada componente. Saiba mais (documentação).

KMZ é um arquivo comprimido (ZIP) contendo seu KML e possíveis imagens utilizadas. Saiba mais (documentação).

É extremamente recomendável que você leia a documentação sobre os dois arquivos.

Sabendo esse mínimo sobre os dois arquivos, vamos escolher o KML por ser mais simples de manipular e de demonstrar o funcionamento.

Não vamos explicar aqui todas as tags do KML para isso consulte a documentação, citaremos apenas as principais tags que compõe nosso exemplo.

Para melhor visualização nosso KML já foi dividido em métodos:

O método abaixo define o cabeçalho de nosso KML (XML) e dá inicio ao documento com a tag <Document> [Atenção o KML é case-sensitive]

Name: especifica o nome do grupo de componentes que vai ser criados para esse documento.

def kml_inicio

    "<?xml version='1.0' encoding='UTF-8'?>
        <kml xmlns='http://www.opengis.net/kml/2.2'
             xmlns:gx='http://www.google.com/kml/ext/2.2'
             xmlns:kml='http://www.opengis.net/kml/2.2'
             xmlns:atom='http://www.w3.org/2005/Atom'>
        <Document>
          <name>Contornos de Propagação para Radiodifusão</name>
          <open>1</open>"

end

Esse segundo segmento é responsável pela definição de cores e largura dos contornos, foram definidas 4 cores para as quatro coordenadas que serão desenhadas. Sendo composta por 6 digitos hexadecimais, observem que ao ser inserida no KML elas recebem 2 outros caracteres, (00 e FF) que são responsáveis pelas definições de opacidade. O 00 garante que o preenchimento não vai ser visível enquanto a linha sim, tanto para modo normal, quando para o modo highlight ( mouse over ), Width é responsável pela largura do contorno.

Após a definição dos 8 estilos (Style>LineStyle)  ( 4 normais e 4 highlight) é criado mais 4 tags responsáveis (StyleMap) que agrupam os outros 8 estilos em pares, definindo assim os 2 estados para cada contorno.

def kml_estilos

    template = ""
    cor={1=>"00ffff",2=>"FF6600",3=>"0000ff",4=>"33CCFF"}
    tipos = ["normal","highlight"]
    (1..4).each do |numero|
      tipos.each do |tipo|
        template+="<Style id='contorno#{numero}_#{tipo}'>
            <LineStyle>
              <color>ff#{cor[numero]}</color>
              <width>2</width>
            </LineStyle>
            <PolyStyle>
              <color>00#{cor[numero]}</color>
            </PolyStyle>
          </Style>"
      end

      template+="<StyleMap id='contorno#{numero}'>
            <Pair>
              <key>normal</key>
              <styleUrl>#contorno#{numero}_normal</styleUrl>
            </Pair>
            <Pair>
              <key>highlight</key>
              <styleUrl>#contorno#{numero}_highlight</styleUrl>
            </Pair>
          </StyleMap>"
    end
    template

end

Após abrirmos as tags do documentos e definirmos os estilos de cores de cada contorno vamos então desenha-los. O método abaixo necessita que seja passado o numero do contorno ( ou seja vai ser chamado 4 vezes, uma para cada contorno) e as coordenadas referentes a cada um destes.

Tags: name: o nome do contorno que irá aparecer no google Earth agrupado pelo primeiro name que definiu o documento.

StyleUrl: O estilo que vai definir as propriedades do contorno.

Polygon>Coordinates: Requer os pares de Lon,lat ( atenção, os pares são invertidos exatamente assim) separados um par de outro por espaço.

def desenhar_poligonos(numero,coordenadas)
    "	<Placemark>
    		<name>Contorno #{numero}</name>
    		<styleUrl>#contorno#{numero}</styleUrl>
    		<Polygon>
    			<tessellate>1</tessellate>
    			<outerBoundaryIs>
    				<LinearRing>
    					<coordinates>
                  #{coordenadas}
              </coordinates>
    				</LinearRing>
    			</outerBoundaryIs>
    		</Polygon>
    	</Placemark>"
end

E por fim, mas não menos importante, vamos fechar nosso arquivo:

def kml_fim

    "\n  </Document>\n</kml>"

end

E para gerar nosso arquivo completo? Muito simples agora:

def kml_default_template(coordenadas)

default_template = kml_inicio

default_template+= kml_estilos

(1..4).each do |numero|

default_template+= desenhar_poligonos(numero, coordenadas[numero])

end

default_template+=kml_fim

end

E pronto. Save o resultado em um arquivo e nomeie como aqualquer_coisa.kml e dê dois cliques, se seu Google Earth estiver instalado normalmente você verá algo parecido com isso:

Polígono desenhado no google Earth via Código

.

Parte 1: Calculando coordenadas finais possuindo um ponto inicial, a distância e o Azimute ( ângulo)

Olá esporádicos leitores do RedRails, hoje vamos começar uma serie sobre cálculos de coordenadas, Google Earth e Ruby. Me foi proposto um problema, um engenheiro de telecomunicações tem um grande trabalho na hora de desenvolver seus projetos quanto ao desenho do alcance de uma antena de radiodifusão, pois deve traçar o raio de alcance dessa antena em todas as direções, ou seja, se ele for considerar os 360 graus do circulo e sendo que deve desenhar quatro contornos de alcance teríamos 1440 pontos, isso dá um trabalho considerável.

Logo abaixo temos uma amostra do resultado a ser atingido. Temos 3 traçados visíveis, pois o contorno 2 e o contorno protegido são equivalentes. A antena é simbolizada pelo triângulo no centro dos contornos, observem a irregularidade apresentada no lado direito da imagem. É exatamente esse o intuído dessa plotagem demonstrar visualmente o alcance e as possíveis adversidades que seu sinal pode encontrar em nosso exemplo uma cadeia de montanhas está obstruindo o sinal.

Como podemos solucionar esse tipo de problema? Primeiro analisaremos nossas variáveis, conhecemos uma coordenada inicial (onde a torre se encontra, ou um provável local para sua implantação): lat1, lon1. A ANATEL disponibiliza para esse tipo de trabalho as distâncias para até os contornos para cada azimute (grau de inclinação da reta em relação ao norte verdadeiro) que em nosso caso vai ser uma sequencia definida da criação do contorno.

Agora para calcular a coordenada referente a cada dado disponibilizado foi a parte mais trabalhosa, depois de algum tempo de pesquisa conseguimos encontrar uma função matemática que resolveu nosso problema.

A Fórmula Direta de Vincenty (Vincenty ‘Direct’ formula)

Para facilitar o entendimento nosso amigo Chris Veness a converteu em algoritmo:

a, b = major & minor semiaxes of the ellipsoid
f = flattening (a−b)/a
φ₁, φ₂ = geodetic latitude
s = length of the geodesic
α₁, α₂ = azimuths of the geodesic (initial/final bearing)

tanU₁ = (1−f).tanφ₁ (U is ‘reduced latitude’)
cosU₁ = 1/√(1+tan²U₁), sinU₁ = tanU₁.cosU₁ (trig identities; §6)
σ₁ = atan2(tanU₁, cosα₁) (1) sinα = cosU₁.sinα₁ (2) cos²α = 1 − sin²α (trig identity; §6)
u² = cos²α.(a²−b²)/b²
A = 1+u²/16384.{4096+u².[−768+u².(320−175.u²)]} (3)
B = u²/1024.{256+u².[−128+u².(74−47.u²)]} (4)
σ = s / b.A (1st approximation), σ′ = 2π

while abs(σ−σ′) > 10^-12 { (i.e. 0.06mm)
cos2σ_m = cos(2.σ₁ + σ) (5)
Δσ = B.sinσ.{cos2σ_m + B/4.[cosσ.(−1 + 2.cos²2σ_m) − B/6.cos2σ_m.(−3 + 4.sin²σ).(−3 + 4.cos²2σ_m)]} (6)   σ′ = σ     σ = s / b.A + Δσ (7)
}

φ₂ = atan2(sinU₁.cosσ + cosU₁.sinσ.cosα₁, (1−f).√[sin²α + (sinU₁.sinσ − cosU₁.cosσ.cosα₁)²]) (8)
λ = atan2(sinσ.sinα₁, cosU₁.cosσ − sinU₁.sinσ.cosα₁) (9)

C = f/16.cos²α.[4+f.(4−3.cos²α)] (10)
L = λ − (1−C).f.sinα.{σ+C.sinσ.[cos2σ_m + C.cosσ.(−1 + 2.cos²2σ_m)]} (difference in longitude) (11) α₂ = atan2(sinα, −sinU₁.sinσ + cosU₁.cosσ.cosα₁) (reverse azimuth) (12)
p₂ = (φ₂, λ₁+L)

E finalmente nosso código em Ruby.

<pre>
<div id="LC4">class Vincent</div>
<div id="LC5">  def initialize(lat1,lon1)</div>
<div id="LC6">    #Origem e Destino</div>
<div id="LC7">    @lat1 = lat1</div>
<div id="LC8">    @lon1=lon1</div>
<div id="LC9"></div>
<div id="LC10">    #---- Dados do Elipsóide de Revolução --------------------------------------</div>
<div id="LC11">    #http://pt.wikipedia.org/wiki/Figura_da_Terra</div>
<div id="LC12">    @a = 6378137 # Maior semi-eixo da Elipsóide Terrestre - WGS66 (1966)[EUA/DoD]</div>
<div id="LC13">    @b = 6356752.3142 # Maior semi-eixo da Elipsóide Terrestre - WGS66 (1966)[EUA/DoD]</div>
<div id="LC14">    @f = 1/298.257223563 #	Achatamento inverso - WGS66 (1966)[EUA/DoD]</div>
<div id="LC15">  end</div>
<div id="LC17">  #------------ ADDONS ------------------------</div>
<div id="LC18">  def todeg(num)</div>
<div id="LC19">    num*57.29578</div>
<div id="LC20">  end</div>
<div id="LC22">  def torad(angle)</div>
<div id="LC23">    angle/57.29578</div>
<div id="LC24">  end</div>
<div id="LC26">  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -</div>
<div id="LC27">  #</div>
<div id="LC28">  #{} Calculate destination point given start point lat/long (numeric degrees),</div>
<div id="LC29">  # bearing (numeric degrees) & distance (in m).</div>
<div id="LC30">  #</div>
<div id="LC31">  # from: Vincenty direct formula - T Vincenty, "Direct and Inverse Solutions of Geodesics on the</div>
<div id="LC32">  #       Ellipsoid with application of nested equations", Survey Review, vol XXII no 176, 1975</div>
<div id="LC33">  #       http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf</div>
<div id="LC34">  #</div>
<div id="LC35">  def calculate(az, dist)</div>
<div id="LC36">    s = dist</div>
<div id="LC37">    alpha1 = torad(az)</div>
<div id="LC38">    cos_alpha1 = Math.cos(alpha1)</div>
<div id="LC39">    sin_alpha1 = Math.sin(alpha1)</div>
<div id="LC41">    tan_u1 = (1-@f) * Math.tan(torad(@lat1))</div>
<div id="LC42">    cos_u1 = 1 / Math.sqrt((1 + tan_u1*tan_u1))</div>
<div id="LC43">    sin_u1 = tan_u1*cos_u1</div>
<div id="LC44">    sigma1 = Math.atan2(tan_u1, cos_alpha1)</div>
<div id="LC45">    sin_alpha = cos_u1 * sin_alpha1;</div>
<div id="LC46">    cos_sq_alpha = 1 - sin_alpha*sin_alpha;</div>
<div id="LC47">    u_sq = cos_sq_alpha * (@a*@a - @b*@b) / (@b*@b)</div>
<div id="LC48">    an = 1 + u_sq/16384*(4096+u_sq*(-768+u_sq*(320-175*u_sq)));</div>
<div id="LC49">    bn = u_sq/1024 * (256+u_sq*(-128+u_sq*(74-47*u_sq)));</div>
<div id="LC51">    sigma = (s / (@b*an))</div>
<div id="LC52">    sigma_p = (2*Math::PI)</div>
<div id="LC53">    while true</div>
<div id="LC54">      cos2_sigma_m = Math.cos(2*sigma1 + sigma);</div>
<div id="LC55">      sin_sigma = Math.sin(sigma)</div>
<div id="LC56">      cos_sigma = Math.cos(sigma)</div>
<div id="LC57">      delta_sigma = bn*sin_sigma*(cos2_sigma_m+bn/4*(cos_sigma*(-1+2*cos2_sigma_m*cos2_sigma_m)-</div>
<div id="LC58">            bn/6*cos2_sigma_m*(-3+4*sin_sigma*sin_sigma)*(-3+4*cos2_sigma_m*cos2_sigma_m)));</div>
<div id="LC59">      sigma_p = sigma;</div>
<div id="LC60">      sigma = s / (@b*an) + delta_sigma;</div>
<div id="LC61">      break if ((sigma.abs-sigma_p) > 1.0e-012) or sigma.abs==sigma_p</div>
<div id="LC62">    end</div>
<div id="LC64">    tmp = sin_u1*sin_sigma - cos_u1*cos_sigma*cos_alpha1;</div>
<div id="LC65">    lat2 = Math.atan2(sin_u1*cos_sigma + cos_u1*sin_sigma*cos_alpha1,</div>
<div id="LC66">      (1-@f)*Math.sqrt(sin_alpha*sin_alpha + tmp*tmp));</div>
<div id="LC67">    lambda = Math.atan2(sin_sigma*sin_alpha1, cos_u1*cos_sigma - sin_u1*sin_sigma*cos_alpha1);</div>
<div id="LC68">    cn = @f/16*cos_sq_alpha*(4+@f*(4-3*cos_sq_alpha));</div>
<div id="LC69">    ln = lambda - (1-cn) * @f * sin_alpha *</div>
<div id="LC70">    (sigma + cn*sin_sigma*(cos2_sigma_m+cn*cos_sigma*(-1+2*cos2_sigma_m*cos2_sigma_m)));</div>
<div id="LC72">    rev_az = Math.atan2(sin_alpha, -tmp);</div>
<div id="LC74">    {:lat=>todeg(lat2),:lon=> @lon1+todeg(ln),:rev_az=>rev_az}</div>
<div id="LC75">#C: -9.740848496159662,-48.04187046994603</div>
<div id="LC77">  end</div>
<div id="LC80">end</div></pre>

Logo mais teremos mais post sobre o assunto.
o Projeto já implementado vocês podem conferir em meu Github

Agradecimentos a Eng. Antonio Ernani por toda colaboração e para geração dos poligonos vejam o próximo post (http://www.redrails.com.br/2010/11/desenho-de-poligonos-no-google-earth-usando-ruby/)

Celular Modelo: W580i
NetBeans: 6.7.1
Plataforma: CLDC/MIDP
Emulador: Java(TM) Plataform Micro Edition SDK 3.0
Dispositivo: ClamShell CldcPhone1
Configuração: CLDC-1.1
Perfil do Dispositivo: MIDO-2.0
Pacote: Mobile Media API 1.1

UNIVERSIDADE FEDERAL DO TOCANTINS
CAMPUS UNIVERSITÁRIO DE PALMAS
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

GETNA: GERADOR DE CÓDIGO RUBY ON RAILS
A PARTIR DE BANCO DE DADOS

Palmas
2008
LUIZ ARÃO ARAÚJO CARVALHO

Resumo
Na literatura, existem vários geradores de código disponíveis que tem como
principal propósito automatizar o processo de desenvolvimento de aplicações em
diversas linguagens de programação. Este trabalho apresenta o desenvolvimento
de um gerador de código, denominado GEtna, com a função de criar as classes a
partir de um determinado banco de dados. Vale a pena ressaltar que o gerador
GEtna difere dos existentes pelas suas funcionalidades disponibilizadas.
O gerador proposto aumenta a velocidade do processo de desenvolvimento
de uma aplicação Rails, pois recebe como entrada tabelas de um banco de dados
relacional (MySQL, PostgreSQL ou SQLite) e fornece como saída toda a estrutura
de arquivos (classes). Vale a pena ressaltar que o GEtna proporciona uma
padronização das classes geradas e, conseqüentemente, sustenta sua legibilidade,
que é um fator muito importante quando se trabalha com equipes de
desenvolvedores. Assim, neste trabalho será apresentada uma descrição sobre
geradores de código, padrões de projeto, métodos de mapeamento e definições de
dados que são fundamentais para o desenvolvimento de um gerador de código.

Palavras-chave: Banco de Dados Relacional, Desenvolvimento de Sistema,
Gerador de Código, Rails.

ABSTRACT

In literature, there are several available code generators that have the main
goal to automatize the application development process for some programming
languages. This work presents the development of a code generator, named GEtna,
that creates classes from a specific database. It’s important to note that GEtna
generator differs of other generators by your available functionalities.
The proposed generator increases the velocity of a Rails application
development process because it receives as input relational database tables
(MySQL, PostgreSQL or SQLite), and provides as output the complete file structure
(class). The GEtna provides a padronization of generated classes and,
consequently, maintains the legibility that is a very important factor when there are
developers’ groups. So, in this work a description about code generators, design
patterns, mapping methods and data definition is presented because they are
essential for a code generator development.

Keywords: Relational Database, System Development, Code Generator, Rails.

Não, não eu não vou Copiar a Monografia toda aqui não, em baixo eu exportei em diversos formatos para que seja aberto não importa a situação. Coloquei também o Original podendo ser usado como Modelo para você redigir sua monografia no padrão usado pela UFT.  Só lembrando consegui um 10 com essa monografia então cuidem muito bem dela.

Original(DocX)

Pdf

Txt

Html

Doc