Dez 6

JodaTime – Java Date que funciona!

Escrito por DClick Team em .NET, 1, 2.0, 4, 6, api, AR, bar, BI, blog, C#, camp, class, classe, classes, código, control, Curso, Cursos, Design, Design Pattern, Diversos, Documentação, efeito, err, exemplo, Exemplos, falha, for, Google, Hibernate, html, ide, IE, if, image, int, interface, internet, Java, lógica, map, mg, O, on, online, Opinião, padrão, pattern, print, problema, RIA, Ria’s Geral, S+S, Sem categoria, singleton, string, Sun, TAT, Tema, Teste, try, Twitter, UI, uint, Vários, XP, zend @ 12 6th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

JodaTime

Não existe segredo quando se fala da implementação de datas no Java: é ruim de usar. Alguns chegam a dizer que é errado usar inclusive, mas não serei tão extremo.
A API de datas do Java é ruim por vários motivos, como por exemplo, é mal documentada, não é Thread Safe, é difícil de manipular datas, e o comportamento nem sempre é o esperado.
Vamos ver como susbtituir a API de datas que vem Out of the Box no Java, por uma mais efetiva, amigável e confiável: JodaTime.

Lembrando do Calendar

Todo programador Java conhece o Calendar, e sabe que para usá-lo, basta seguir o Design Pattern singleton, ou seja, basta chamar o método de classe em Calendar que devolve a instância única do sistema para o Calendar.

Problema: não funciona.

Não funciona porque se a instância é singleton, e não utiliza threadlocking no código, então não é uma instância ThreadSafe. Logo toda vez que chamamos o getInstance() do Calendar, obtemos uma nova instância. Para ilustrar, crie um teste em JUnit 4 com o seguinte código:

1
2
3
4
5
6
7

Calendar calendar = Calendar.getInstance();

System.out.println(calendar.getTime());

Calendar calendar2 = Calendar.getInstance();

Assert.assertTrue(calendar == calendar2);

Rode o teste e veja a barra do JUnit ficar vermelha. O comparador ‘==’ usado em objetos, compara pelo endereço de memória, o que deveria ser o mesmo se fosse seguido o padrão singleton de verdade.
Pra piorar, todos os métodos que alteram as intâncias do Date estão expostos (por mais que estejam depreciados) para mantêr compatibilidade com versões anteriores da VM. Portanto o Date também não é ThreadSafe, pois não existe controle de concorrência em sua implementação.
Agora vamos deixar o Date e o Calendar de lado, e vamos ao JodaTime.

DateTime

O JodaTime diferencia muito bem os conceitos de data, instante de tempo, período, etc. A classe mais básica (interface no caso) é a ReadableInstant. Não precisa dizer que todas as modelagens de data implementam essa interface, permitindo comparar todos os tipos de modelagem de tempo pontuais. Um período não descreve um único instante ou ponto no tempo, por exemplo.
DateTime é talvez o ReadableInstant mais conhecido, e funciona muito parecido com o Date do Java.
Fatores que tornam o DateTime mais amigável são: é ThreadSafe pois é imutável, é muito bem documentado, e é muto fácil realizar operações com data. Vamos escrever um pouco de código para entender o que se passa.
Comece criando um DateTime. Como no Java, este DateTime criado possui o instante atual do sistema. Em seguida para efeito de teste (o teste pode falhar dependendo de quando for executado), adicione um dia na data criada, e verifique que o novo date aponta para amanhã:

1
2
3
4
5

DateTime date = new DateTime();

date = date.plusDays(1);

Assert.assertEquals(new DateTime().getDayOfYear() + 1, date.getDayOfYear());

Repare que tive que reassociar o date para que ele pudesse ser alterado, afinal DateTime é imutável, o mesmo comportamento que o BinInteger possui. Repare também que pra adicionar um dia, basta chamar plusDays. Este método já se encarrega de fazer toda a lógica de adicionar um dia na data, como por exemplo mudar o mês ou ano se for preciso, por isso se esse teste for rodado no dia 31 de dezembro, ele irá falhar pois o DateTime irá adicionar mais um dia a data, e perceberá que se trata do ano seguinte, e portanto getDayOfYear irá devolver ’1′, e não ’366′ ou ’365′ como esperado.
O JodaTime também trata anos bissestos e horário de verão se for selecionado o fuzo correto.
Existe uma API bem completa em DateTime para manipular todos os campos possíveis da data, sendo assim fica muito mais fácil iterar ao longo dos dias, sem precisar delegar pro Calendar a tarefa, e depois recuperar o resultado.
Não vou abordar muito da API do JodaTime, pois está muito bem documentada e existem muitos exemplos nas internet. O objetivo desse post é tratar do assunto do próximo tópico.

JodaTime e Hibernate

Pior que manipular datas, é persistir datas. Cada banco persiste data do seu próprio jeito, e cada implementação de ORM trata o Date do seu próprio jeito. Mas se você está utilizando o Hibernate, o JodaTime tem uma solução de padronização pra você: JodaTime Hibernate.
Com o JodaTime Hibernate é possível mapear diversos tipos de representação de data em suas classes Java, com ou sem TimeZone, como String ou bigint, como período ou duração, etc.
Para se ter uma idéia do que é possível, basta verificar a documentação online.
E para utiliza é muito fácil. Imagine que você tenha uma entidade com um campo DateTime, que se chama entryDate, portanto temos o getter:

1
2
3
4

@Column(nullable = false)
public DateTime getEntryDate()
return entryDate;

Para tornar este DateTime uma data que é padrão do banco que será utilizado, por exemplo, basta adicionar a seguinte anotação:

1
2
3
4
5

@Column(nullable = false)
@Type(type = “org.joda.time.contrib.hibernate.PersistentDateTime”)
public DateTime getEntryDate()
return entryDate;

Estamos falando para o hibernate utilzar o tipo de coluna descrito pelo PersistentDateTime, e utilizar o mesmo para converter a data novamente para DateTime quando for recuperado.
Caso você esteja fazendo engenharia reversa de algum banco, recomendo ler a descrição de todos os tipo disponíveis pra fazer a melhor escolha.
Com isso conseguimos obter todos os benefícios do JodaTime em nossas entidades, facilitando controlar as datas no domínio de nossas aplicações.

Espero ter despertado sua curiosidade com o JodaTime. Na minha opinião é uma das melhores bibliotecas Java disponíveis, mas não quero falar muito sobre suas funcionalidades, pois um dos pontos mais fortes da biblioteca é a facilidade de se acostumar com ela, e principalmente utilizar todos seus recursos. Quero que vocês tenham um pouco desse gostinho .

Por @Gust4v0_H4xx0r

Nov 16

Spring 3.1 RC1 – @Configuration

Escrito por DClick Team em 1, 2.0, 4, 6, action, app, AR, auto, bar, BI, blog, busca, C#, case, class, classe, classes, código, components, configuração, err, erro, error, exemplo, for, framework, Google, IE, if, int, Java, lite, map, mudanças, mvc, NaN, O, on, Plugin, refresh, rest, RIA, Ria’s Geral, RoR, S+S, Sem categoria, Spring, SpringFramework, string, Sun, super(), tag, TAT, Teste, Twitter, UI, uint, web, XML @ 11 16th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Spring @Configuration

O que há de novo

Para habilitar certas funcionalidades do Spring que envolvem AOP, era preciso escrever tags XML como por exemplo context:component-scan para especificar os pacotes em que o Spring pode buscar por beans anotados com @Component, @Repository ou @Service.
Na versão 3.1 foram disponibilizadas as mesmas funcionalidades via anotação. São elas:

1
2
3
4
5
6
7
8

org.springframework.context.annotation.Configuration
org.springframework.context.annotation.ComponentScan
org.springframework.context.annotation.EnableLoadTimeWeaving
org.springframework.context.annotation.EnableAspectJAutoProxy
org.springframework.scheduling.annotation.EnableScheduling
org.springframework.scheduling.annotation.EnableAsync
org.springframework.transaction.annotation.EnableTransactionManagement
org.springframework.web.servlet.config.annotation.EnableWebMvc

Vamos abordar o caso básico, pois o resto é bem similar.

@ComponentScan

Caso você ainda não esteja familiarizado com as configurações por anotaçãoo, vamos ao básico.
Comece criando uma classe que representará seu container de beans, e a anote com @configuration:

1
2
3
4

@Configuration
public class TestConfiguration

Nesta classe estarão os beans que o container irá instanciar e deixar a nossa disposição.
Para iniciar o container vamos criar um test (JUnit 4) que instancia o contexto:

1
2
3
4
5
6
7
8
9
10
11

public class ConfigurationTestCase

@Test
public void testConfigurationBeans()

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(TestConfiguration.class);
ctx.refresh();

}

Aqui criamos um container do tipo AnnotationConfigApplicationContext e registramos nossa classe de configuração nele. Repare que é possível registrar mais classes, e portanto disponibilizar mais beans no container.
Agora vamos criar nosso bean de teste:

1
2
3
4
5
6
7
8
9
10
11
12
13

public class GenericBean

private String testProperty;

public GenericBean(String testProperty)
super();
this.testProperty = testProperty;

public String getTestProperty()
return testProperty;

}

Vamos criar os métodos em nossa classe de configuração que instanciam nosso bean de duas maneiras diferentes:

1
2
3
4
5
6
7
8
9

@Bean(name = “testBean”)
public GenericBean genericTestBean()
return new GenericBean(“test”);

@Bean(name = “otherBean”)
public GenericBean genericOtherBean()
return new GenericBean(“other”);

Repare que a única diferença entre os dois é a String que passamos como parâmetro.
Agora que temos 2 beans diferentes em nosso container, vamos criar os testes para verificar o comportamento do Spring. Abaixo da inicialização do contexto, vamos adicionar as seguintes linhas:

1
2
3
4
5
6
7
8
9

GenericBean testBean = ctx.getBean(“testBean”, GenericBean.class);

Assert.assertNotNull(testBean);
Assert.assertEquals(“test”, testBean.getTestProperty());

GenericBean otherBean = ctx.getBean(“otherBean”, GenericBean.class);

Assert.assertNotNull(otherBean);
Assert.assertEquals(“other”, otherBean.getTestProperty());

Aqui estamos garantindo que nossos dois beans diferentes estarão no contexto como esperado.
Antes de rodar o teste, será necessário adicionar a dependência do CGLib ao seu projeto. Caso você esteja usando o maven, basta adicionar a seguinte dependência>

GeSHi Error: GeSHi could not find the language text (using path C:Program Fileswampwwwblogwp-contentpluginsig_syntax_hilitegeshi) (code 2)

Pronto, com isso temos o suficiente pra deixar a barra do JUnit verde. Vamos agora adicionar o @ComponentScan.
Em nossa classe de configuração (poderia ser qualquer outra registrada no contexto) adiciona a seguinte anotação:

1
2
3

@Configuration
@ComponentScan(“br.com.dclick.tentativas.configuration.beans”)
public class TestConfiguration

No meu caso meu bean está dentro do pacote br.com.dclick.tentativas.configuration.beans e portanto basta eu alterá-lo adicionando o seguinte código:

1
2
3
4
5
6
7
8

@Component(“componentBean”)
public class GenericBean

private String testProperty;

public GenericBean()
this.testProperty = “component”;

Dessa forma posso criar mais um teste e verificar que o bean está vindo corretamente:

1
2
3
4

GenericBean componentBean = ctx.getBean(“componentBean”, GenericBean.class);

Assert.assertNotNull(componentBean);
Assert.assertEquals(“component”, componentBean.getTestProperty());

Rode o teste e deixa o JUnit feliz.
A única coisa a se ter cuidado aqui, é que com @ComponentScan, você não pode mapear o diretório da própria classe de configuração.

Demais Configurações

Daqui em diante basta anotar suas classes de configuração com as configurações que você deseja ativar, como por exemplo @EnableAsync que permite que os beans rodem de maneira assíncrona com a anotação @Async.

Brinque um pouco com as outras anotações. Acredito que vale o esforço, pois esse tipo de configuração permite abandonar um pouco os arquivos XML e tornam mais fácil o refactor dos beans, afinal teremos erros de compilação com as mudanças de código.

Por enquanto é isso, qualquer dúvida mande nos comentários que responderei assim que possível.

Por @Gust4v0_H4xx0r

Nov 9

Conhecendo o LESS. The Dynamic Stylesheet.

Escrito por DClick Team em 1, 2.0, 4, 6, Adobe, Air, app, apple, AR, back, BI, browser, C#, class, classe, classes, código, css, css3, Curso, Cursos, custom, dados, demo, Desenvolvedor, Desenvolvimento, Desenvolvimento Web, Design, Destaque, Dica, Diversos, Documentação, dynamic, empresas, err, erro, error, Estilo, exemplo, Exemplos, for, function, gc, Google, html, html5, ide, IE, if, int, Java, Javascript, kit, layout, menu, Microsoft, MIX, NaN, O, on, Opinião, Outros, padrão, problema, problemas, programação, prova, pt, referencia, RIA, Ria’s Geral, RoR, S+S, Sem categoria, site, tag, TAT, Twitter, UI, uint, Utilidades, Ved, web, zend @ 11 9th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Como todos devem ter percebido, nos últimos meses o CSS3 e o HTML5 tem ganho um grande destaque no desenvolvimento web. Grandes empresas como o Google, Microsoft, Adobe e Apple estão apoiando fortemente o desenvolvimento web utilizando WebStandards. Caso você já conheça algo sobre CSS, provavelmente deve saber como é complicado a organização desses documentos em um projeto de médio ou grande porte. Dado esses problemas conhecidos, foram surgindo os chamados pré-processadores de CSS, que viabilizam a criação de documentos de estilo, adicionando novas funcionalidades.

Hoje vamos conhecer o LESS, The Dynamic Stylesheet Language. O objetivo dessa biblioteca em javascript é prover uma série de funcionalidades para as, usualmente criadas a mão, folhas de estilos. Recursos tais como, variáveis, mixins (Multiple Inheritance, Traits), mixins parametrizáveis, funções, namespaces, importação, etc. Vamos aprender como utilizar os principais recursos dessa biblioteca em um projeto e como aproveitar o melhor dessa biblioteca para organizar corretamente nossas folhas de estilo.

Variables

As variáveis ajudam-nos a definir valores que podem ser utilizados em diversas regras do nosso CSS. Elas possuem escopo assim como em uma linguagem de programação orientada a objetos, trocando em miúdos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Arquivo stylesheet.less
// Essa variável foi definida no escopo do arquivo, logo, todas as regras do arquivo podem acessar seu valor.
@siteBackgroundColor: #FF3300; // Laranja

h1
// A variável headingColor foi criada no escopo da regra h1, logo, apenas ela e outras regras criadas dentro
// do mesmo escopo tem acesso ao seu valor.
@headingColor: #333333; // Cinza

// Isto significa que, se criarmos uma outra regra chamada &.mainTitle
// Observe o uso do &.classe, isso copia a regra pai e associa uma classe, o output disso seria exatamente h1.mainTitle
&.mainTitle
// Como essa regra esta contida na regra h1, podemos acessar o valor da variável headingColor.
color: @headingColor;

}

h2
// Se tentarmos acessar o valor nessa regra, que não encontra-se contida na regra h1, receberemos um erro da biblioteca
// informando que a variável headingColor não encontra-se definida.
color: @headingColor; // Brrrrrr! Error.

O que é interessante no uso de variáveis é a reutilização e organização. Imagine uma design guideline onde existem RGBs específicos a serem seguidos, essas cores poderiam ser definidas em um documento chamado color_variables.less e adicionados ao nosso arquivo principal utilizando a clausula @import.

@Import – Importando outros arquivos

Quando um arquivo LESS é importado, todas as suas variáveis e mixins são adicionados ao arquivo principal. Os escopos serão mantidos e a extensão .less é opcional.

@import “lib.less”
@import “lib”

É possível utilizar pastas nas clausulas de @import:

@import “where/is/my/stylesheet.less”
@import “where/is/my/stylesheet”

Mixins

No LESS, mixis são como uma espécie de classe CSS que pode ser reutilizada em diversas outras regras. Quando utilizadas, todas as propriedades definidas no mixin são adicionadas a regra onde a mesma foi adicionada, caso um mixin mude, todas as regras que o referenciam serão também modificadas.

Imagine o conceito de mixin como classes CSS orientadas a objeto, o que é interessante do mixin é que temos aqui algo como uma herança múltipla, caso uma mesma instrução seja declarada em mixins diferentes, e esses mixins adicionados a uma regra, o mixin declarado por último terá vantagem na construção final do CSS da regra onde foi adicionado.

1
2
3
4
5
6
7
8
9
10
11
12

.bordered
border-top: dotted 1px black;
border-bottom: solid 2px black;

// Declaramos agora uma regra qualquer que fará uso do nosso mixin.
div.someDiv
.bordered; // Simples assim, adicionamos todas as propriedades contidas no mixin em nossa regra.

div.anotherDiv
.bordered; // A mesmas propriedades serão adicionadas nessa regra.

Quando modificarmos o mixin .bordered, todos os elementos que o estão utilizando serão modificados. Reutilização!
Vamos para um exemplo mais usável para exemplificar como é um mixin parametrizável.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Bordas arredondadas cross-browser.
// Observe que utilizamos algo parecido com uma função de javascript para declararmos nosso mixin.
// A notação de variável deve ser adicionada (@radius), com isso, criamos uma variável chamada “radius” no escopo
// do mixin que poderá ser utilizada apenas internamente pelo método.
// Observe também que declaramos um valor padrão para o parâmetro, de 5px.
.border-radius( @radius: 5px )

// Repare que utilizamos a mesma variável para todas as regras.
border-radius: @radius;
-moz-border-radius: @radius;
-webkit-border-radius: @radius;

// Para utilizarmos a regra, seguimos o mesmo padrão
div.someDiv
.border-radius; // Nesse caso estaremos utilizando o valor padrão de 5px.

div.anotherDiv
.border-radius(10px); // Nessa aplicação, modificamos o valor da propriedade para 10px.

É importante destacar que um mixin pode conter diversos parâmetros. Isso pode ser feito da seguinte forma:

1
2
3
4
5
6

// Declaramos um novo mixin
.border-radius-and-color( @radius: 5px, @borderColor: #000000 )

.border-radius( @radius ); // Observe que aqui reutilizei o mixin previamente definido. Composição de mixins.
border: 2px solid @borderColor; // Adicionamos agora a cor para a borda.

Nested Rules

Com o LESS você pode criar suas regras de CSS utilizando uma espécie de hierarquia. Vamos ver como isso funciona na prática.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Dado o CSS abaixo
div#header #menu
…
rules

div#header #menu li a
…
more rules

div#header #topNav
…
another rules

Com o LESS, o mesmo CSS acima poderia ser escrito da seguinte forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Como utilizar hierarquia com Less
div#header
#menu
ul
li

}
}

#topNav

}

Depois de processado, o CSS será exatamente igual. Você não precisa utilizar esse esquema de hierarquia caso não queira, é importante lembrar que o LESS é apenas uma extensão do CSS, se for de desejo do desenvolvedor, podemos escrever um código LESS sem usar nenhum recurso especial, como se fosse um CSS tradicional.

Operations

Com o LESS o seu CSS sabe fazer contas. Qualquer número, cor ou variável pode ser utilizada em uma operação aritmética.
Ele sabe identificar quando estamos utilizando uma cor ou um número, por exemplo:

1
2
3
4
5
6
7

@base: 5%;
@filler: @base * 2;
@other: @base + @filler;

color: #888 / 4;
background-color: @base-color + #111;
height: 100% / 2 + @filler;

Assim como no javascript, é possível também utilizar parênteses nas suas operações:

1	width: (@var + 5) * 2;

Color Functions

Na minha opinião um dos recursos mais úteis durante o desenvolvimento de uma aplicação. Podemos efetuar operações em cima de RGBs, por exemplo, imagine que o layout do seu website foi criado baseado-se em apenas uma cor, utilizando diversos tons dessa cor. Com o LESS é possível utilizar métodos pré-definidos como lighten, saturate, darken, fadein, fadeout e spin. Esses métodos retornam sempre um RGB que pode ser utilizado em seu LESS. Vejamos alguns exemplos:

1
2
3
4
5
6
7
8
9

@base: #f04615;

.class
// Saturo em 5% a cor base.
color: saturate(@base, 5%);

// Utilizo a cor base 25% mais clara
background-color: lighten(@base, 25%);

É possível também extrair informações de uma determinada cor para ser utilizada em outra.
Isso é feito a partir dos métodos hue, saturation e lightness.

1
2
3

hue(@color); // retorna o valor do canal ‘hue’ da cor @color
saturation(@color); // retorna o valor do canal ‘saturation’ da cor @color
lightness(@color); // retorna o valor do canal ‘lightness’ da cor @color

Namespaces

Em dado momento necessitamos organizar uma série de mixins e variáveis. Para isto podemos utilizar um conceito presente no LESS chamado Namespaces. Assim como em linguagens de programação orientadas a objetos, que possuem o conceito de pacotes, os namespaces fornecem encapsulação para nossas folhas de estilo. Isso pode ser implementado facilmente utilizando a mesma notação de ID do CSS tradicional. Vejamos.

1
2
3
4
5
6
7
8
9
10
11
12

#bundle

.button ()

display: block;
border: 1px solid black;
background-color: grey;
&:hover background-color: white
}
.tab …
.citation …
}

Verifique que acima, criamos um mixin chamado button dentro do namespace bundle. Para o utilizarmos devemos fazer da seguinte forma:

1
2
3
4

#header a
color: orange;
#bundle > .button; // Estamos acessando o namespace ‘bundle’ e fazendo uma chamada para o mixin ‘button’.

Uma utilização muito comum dos namespaces é na criação de pequenas bibliotecas de utilidades. Imagine que sua empresa pode possuir uma série de arquivos LESS, e em um determinado projeto você necessita de acesso a esses mixins, variáveis, etc. Organizar seus documentos com namespaces fácilita a visualização e localização de uma determinada instrução no seu documento LESS, como por exemplo, um mixin customizado que pode ser facilmente encontrado a partir da sua indicação de namespace.

1
2
3

someRule
#dclick > .border-radius(10px);

Conclusão

Como podemos ver, o LESS facilita uma série de tarefas que são praticamente impossíveis de serem efetuadas pelo CSS tradicional.
Aconselho a todos que tenham interesse em se aprofundar mais na biblioteca a conhecer o website (http://lesscss.org/). Lá você poderá encontrar a documentação com maior riqueza de informações também poderá ver alguns exemplos de código que não foram abordados nesse post.

Qualquer dúvida, sinta-se a vontade e envie-nos um comentário!
Abraço!

Nov 8

Spring 3.1 RC1 – Cache Abstraction

Escrito por DClick Team em 1, 2.0, 4, 6, action, app, AR, Arquitetura, Banco de Dados, BI, blog, C#, cache, class, classe, configuração, dados, Documentação, Download, err, erro, exemplo, for, framework, Google, html, ide, IE, if, int, interface, Java, lite, map, mapa, O, on, Outros, padrão, pt, reference, RIA, Ria’s Geral, S+S, Sem categoria, site, Spring, Spring Framework, SpringFramework, string, Sun, tag, TAT, Teste, Twitter, UI, uint, XML, zend @ 11 8th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Spring Cache Abstraction

Abordamos um das novas funcionalidades do Spring 3.1 RC1, profiles e environments. Ainda existem outras funcionalidades, mas hoje iremos dar uma olhada em Cache Abstraction.

Cache Abstraction é literalmente uma abstração out of the box para adicionar uma camada de cache sobre seus beans, usando uma arquitetura AOP para gerenciar o que deve e o que não deve ser feito o cache.
Usar a nova camada de cache é muito fácil se você já está habituado com Spring, e veremos uma das diferentes maneiras de configurar seus beans.

Baixando a Denpendência

Para quem utiliza maven, basta adicionar a seguinte dependência no pom do seu projeto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

>
>
>org.springframework.maven.milestone>
>Spring Maven Milestone Repository>
>http://maven.springframework.org/milestone>
>
>

>
>
>org.springframework>
>spring-core>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-context>
>3.1.0.RC1>
>
>

Se você perferir, pode baixar os jar direto do site do spring.
Sem segredos aqui, basta adicionar as dependências ao projeto e está pronto para usar.

Entendendo o funcionamento

A maneira com que o cache funciona é bem simples. Você pode enxergar o cache como um mapa chave-valor, onde a chave é o conjunto de argumentos do seu método, e o valor é o valor devolvido pelo seu método. Pensando assim fica fácil entender o funcionamento que irei mostrar no exemplo.
Referente a configuração do Spring, é necessário instanciar um gerenciador de cache, ou na linguagem spring, cacheManager. Existe algumas implementações de cache manager disponível no spring, portanto iremos utilizar uma delas em nosso exemplo.
Vamos escrever um teste unitário com JUnit 4.8.1 para ilustrar o comportamento do cache.
Comece criando um arquivo padrão de beans do spring, mas com um namespace a mais:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

>
Repare que estamos utilizando o namespace de cache além dos usuais.
A única configuração que iremos fazer aqui, é a do cache manager. Crie um bean da classe >SimpleCacheManager> e adicione o seguinte bean como cache gerenciado:
>
cc lang=”XML”
public interface CacheableTest

@CacheEvict(value = “property”, allEntries = true)
void evictCache();

@Cacheable(“property”)
String getForCache(String s);

String getProperty();

void setProperty(String property);

Repare no getter e setter que usaremos no teste, e na anotação @Cacheable(“property”). Esta anotação está dizendo que o valor que este método devolver será armazenado no cache que configuramos previamente como property. Fato importante é que este valor é referente ao argumento passado como parâmetro no método.
A outra anotação @CacheEvict(value = “property”, allEntries = true) descreve o método que chamaremos para esvaziar o cache. Note que passamos o nome do cache, e que ele deve limpar todos os valores.
É importante notar também que pode ser passado mais de um nome de cache em ambas as anotações.
Uma implementação básica para nosso bean pode ser:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Component(“cacheBean”)
public class CacheableBean implements CacheableTest

private String property;

public String getForCache(String s)
return this.property;

public String getProperty()
return property;

public void setProperty(String property)
this.property = property;

public void evictCache()
// Não faz nada

}

Estou usando o package scan para instanciar o bean. Agora nosso teste:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class CacheTest

@Test
public void testCache()

ApplicationContext ctx = new ClassPathXmlApplicationContext(
“spring31-test-beans.xml”);

CacheableTest bean = ctx.getBean(“cacheBean”, CacheableTest.class);

bean.setProperty(“teste”);

Assert.assertEquals(“teste”, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));

bean.setProperty(“teste2″);
Assert.assertEquals(“teste2″, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));
Assert.assertEquals(“teste2″, bean.getForCache(“b”));

bean.setProperty(“teste3″);
Assert.assertEquals(“teste3″, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));
Assert.assertEquals(“teste2″, bean.getForCache(“b”));

bean.evictCache();
bean.setProperty(“teste4″);
Assert.assertEquals(“teste4″, bean.getProperty());
Assert.assertEquals(“teste4″, bean.getForCache(“a”));
Assert.assertEquals(“teste4″, bean.getForCache(“b”));

}

O arquivo de beans se chama spring31-test-beans.xml.
Repare que estamos invocando o método getForCache passando alguns valores diferentes, e o valor devolvido é sempre igual, mesmo que depois setamos um valor diferente ao bean. Para atualizar o valor e limpar o cache, basta invocar o método evictCache que havíamos anotado com @CacheEvict.
Vale a pena brincar um pouco com o funcionamento do cache, e até mesmo criar outros caches e ver o comportamento do evict em diferentes métodos.

Últimas Considerações

As mesmas configurações que fizemos com anotações, pode-se fazer direto no XML. Não entrarei no detalhe pois o funcionamento é exatamente o mesmo, mas se você preferir basta olhar a documentação que é bem straightforward.
Lembre-se que esta camada de cache não possui nenhuma relação com o banco de dados, e deve ser usada com muito cuidado em tais casos, pois alguns erros de concistência podem aparecer devido a um cache desatualizado.
Vale a pena brincar com o cache manager, pois o spring suporta o uso do EhCache, o que pode ser muito útil se você já possui alguma configuração pré-definida para sua aplicação.

Por enquanto é isso, qualquer dúvida mande nos comentários que responderei assim que possível.

Por @Gust4v0_H4xx0r

Nov 4

Spring 3.1 RC1 – Profiles

Escrito por DClick Team em 1, 2.0, 4, 6, Air, app, AR, Banco de Dados, bar, BI, C#, carregar, class, código, dados, demo, Desenvolvimento, Dica, dispatch, Download, err, exemplo, for, framework, Google, ide, IE, if, int, interface, Java, LOB, lógica, novidade, Novidades, O, on, Outros, override, refresh, Release Candidate, RIA, Ria’s Geral, S+S, Sem categoria, site, Spring, SpringFramework, string, Sun, TAT, Teste, Twitter, UI, uint, web, XML, zend @ 11 4th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Profiles e Environments no novo Spring 3.1

A SrpingSource adotou a estratégia de soltar mais versões do Spring com mais velocidade e escopos de funcionalidades menores.
Seguindo tal estratégia acabou de sair do forno o primeiro release candidate da versão 3.1 do framework.
Para uma estratégia de escopos menores, até que tiveram bastante trabalho e adicionaram várias novidades. Vamos cobrir as novidades aos poucos, começando com uma muito interessante: Profiles e Environments.

Especificando Profiles nos Beans

A idéia de um profile é simples. Um profile define um escopo, envirnmente como é chamado no framework, em que certos beans estarão disponíveis e outros não.
Imagine que você precisa de uma conexão com o banco de dados de testes, que é diferente do banco de dados de desenvolvimento. Com profiles podemos definir um data source do profile de desenvolvimento, e outro do profile de testes, instanciando o correto de acordo com o ambiente que a aplicação irá rodar.

Anotações

Para especificar um profile no seu bean, basta adicionar a anotação @Profile com o nome do profile correspondente. Lembrando que este é o caso em que seus Beans estão sendo criados pelo component-scan usando package scan. Vamos criar um exemplo pra ficar mais claro o que acontece.
Vamos criar uma interface comum para nossos beans:

1
2
3
4
5

public interface ProfileEspecificBean

String recoverActiveProfile();

Agora vamos criar dois profiles e dois beans diferentes para a mesma interface. Um é o bean de desenvolvimento (dev) e o outro de testes (qa).

1
2
3
4
5
6
7
8
9
10

public final class Profiles

private Profiles()

public static final String DEV_PROFILE = “dev”;

public static final String QA_PROFILE = “qa”;

}

1
2
3
4
5
6
7
8
9
10
11
12

package br.com.dclick.tentativas.beans;

@Component(“profileBean”)
@Profile(DEV_PROFILE)
public class DevEspecificBean implements ProfileEspecificBean

@Override
public String recoverActiveProfile()
return DEV_PROFILE;

}

1
2
3
4
5
6
7
8
9
10
11
12

package br.com.dclick.tentativas.beans;

@Component(“profileBean”)
@Profile(QA_PROFILE)
public class QAEspecificBean implements ProfileEspecificBean

@Override
public String recoverActiveProfile()
return QA_PROFILE;

}

Repare que já anotei os beans com @Profile respeitando os profiles específicos de cada bean.
Agora criamos o arquivo de beans do spring, dei o nome de spring31-test-beans.xml:

1
2
3
4
5
6
7
8
9
10
11

<?xml version=“1.0″ encoding=“UTF-8″?>
xmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance” xmlns:context=“http://www.springframework.org/schema/context”
xsi:schemaLocation=“http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd”>

:component-scan base-package=“br.com.dclick.tentativas.beans” />

Feito isso, vamos criar um teste para verificar a lógica de criação dos beans. estou usando JUnit 4.8.1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class ProfileBeansTest

@Test
public void testProfileDev()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(DEV_PROFILE);
ctx.load(“classpath:spring31-test-beans.xml”);
ctx.refresh();

// Profile de DEV
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(DEV_PROFILE, profileBean.recoverActiveProfile());

@Test
public void testProfileQA()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(QA_PROFILE);
ctx.load(“classpath:spring31-test-beans.xml”);
ctx.refresh();

// Profile de QA
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(QA_PROFILE, profileBean.recoverActiveProfile());

}

Algumas coisas diferentes estão acontecendo nesse teste.
Estou instanciando um GenericXmlApplicationContext para carregar meus arquivos de beans, isso porque esse application context me disponibiliza um método que é importante para nosso teste: getEnvironment(). Com isso conseguimos acessar o environment do application context, e mais do que isso, conseguimos setar os profiles que estão ativos usando setActiveProfiles. Repare que é possível de setar mais de um profile como ativo, e que os beans podem precisar de mais de um profile para serem instanciados.
Outro fato importante, é que este environment que está disponível, é uma instância de ConfigurableEnvironment. Se você tentar acessar o profile diretamtente em ApplicationContext, você estará acessando um Environment o qual não permite ativar e desativar profiles. Fica a dica.

Após ativar o profile que queremos, basta chamar o load no contexto seguido do refresh para que os beans sejam criados.
Uma vez que o bean foi criado, basta recuperá-lo e executar o teste para se certificaro que se trata do bean que estamos esperando. Note que o nome dos dois beans é o mesmo, e que apenas um deles existe no application context, pois o outro profile não está ativo.

Nested Beans

Outra maneira de definir profiles nos beans é diretamente no XML do spring. Para que isso seja possível foi necessário permitir nested beans nos arquivos de beans, ou seja, definições de beans dentro de outra definição.
Além de possibilitar a definição de diferentes profiles, essa nova funcionalidade permite que sejam definidos alguns padrões de comportamento para os beans que só se apliquem no conjunto de beans que está nested. Mas isto veremos em um próximo post.
Para testar a definição de profiles direto no XML, vamos criar um outro XML chamado spring31-test-nested-beans.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

profile=“dev”>
class=“br.com.dclick.tentativas.beans.DevEspecificBean” id=“profileBean” />
>

profile=“qa”>
class=“br.com.dclick.tentativas.beans.QAEspecificBean” id=“profileBean” />
>

Feito isso, vamos criar um novo teste que é idêntico ao primeiro, com exceção do arquivo de beans especificado, afinal o comportamento deve ser o mesmo em ambos os casos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@Test
public void testProfileDevXml()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(DEV_PROFILE);
ctx.load(“classpath:spring31-test-nested-beans.xml”);
ctx.refresh();

// Profile de DEV
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(DEV_PROFILE, profileBean.recoverActiveProfile());

@Test
public void testProfileQAXml()

GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.getEnvironment().setActiveProfiles(QA_PROFILE);
ctx.load(“classpath:spring31-test-nested-beans.xml”);
ctx.refresh();

// Profile de QA
ProfileEspecificBean profileBean = ctx.getBean(“profileBean”,
ProfileEspecificBean.class);

Assert.assertEquals(QA_PROFILE, profileBean.recoverActiveProfile());

Sua barra do JUnit vai ficar verde e você vai ficar feliz com essa brincadeira rápida com profiles.

Ativando Profiles de outras maneiras

Ativa os profiles no código funciona muito bem no caso dos testes, mas o que realmente se aplica a vida real é poder ativar tais profiles de maneira independente da aplicação e do código propriamente dito. Por isso podemos ativar os profiles setando uma variável global chamada spring.profiles.active.
Podemos ativar tal variável de diversas maneiras, dentre elas no próprio web.xml como um parâmetro da sua Servlet do Spring:

1
2
3
4
5
6
7
8

>
-name>dispatcher-name>
-class>org.springframework.web.servlet.DispatcherServlet-class>
-param>
-name>spring.profiles.active-name>
-value>qa-value>
-param>
>

Podemos usar também JNDI, ou até mesmo uma variável de ambiente da VM Java. Se você preferir também pode ativar profiles diretamente no maven:

1	-Dspring.profiles.active=”profile1,profile2″

Fazendo Download

Se você usa o maven, basta adicionar o seguinte no seu pom:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

>
>
>org.springframework.maven.milestone>
>Spring Maven Milestone Repository>
>http://maven.springframework.org/milestone>
>
>

>
>
>org.springframework>
>spring-core>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-beans>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-context>
>3.1.0.RC1>
>
>

Caso você queira baixar diretamente do site, acesse o site do spring.

Espero ter sido útil, qualquer pergunta basta enviar nos comentários.

Por @Gust4v0_H4xx0r

Out 28

Adobe Tutorial Builder – Plugin para Photoshop

Escrito por DClick Team em 1, 2.0, 3.5, 3d, 4, 6, action, Adobe, AR, arte, blog, C#, class, comparação, Design, designer, Dica, Gravação, html, IE, if, image, int, labs, Links, mg, O, on, Partilha, photoshop, Plugin, problema, pt, RIA, Ria’s Geral, S+S, site, social, super(), TAT, Tech, Tutorial, Twitter, UI, uint, Vídeo, window, XML, XP @ 10 28th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Você designer, que ama Photoshop e já está em um nível bacana, já deve ter feito algum tutorial e postado em algum Blog, site, ou em alguma rede social… é a nossa natureza, querer compartilhar algumas técnicas, mas o grande problema é que isso é trabalhoso, e logo as pessoas param de faze-lo.

Agora, imagine você poder compartilhar o passo a passo de uma atividade sua no Photoshop sem dor de cabeça, sem ter que fazer nada, somente alguns cliques. Isso mesmo, poder ter algo escrito mostrando tudo que você fez no Photoshop sem ter que se matar em descrever todos os ? passos.

A Adobe maravilhosamente criou o Tutorial Builder (Adobe Labs), um plugin simples para Photoshop mas no mínimo, muito, mas muito poderoso.

A idéia consiste no seguinte, você baixa o plugin, instala e ele abre como Panel do Photoshop.

Após instalar, basta ir em Window > Extensions > Tutorial Builder.
Vai abrir essa janelinha bacana que você pode ver na imagem abaixo:

Uma vez aberto você clicando em Start vai (obviamente) iniciar a gravação, que no final, pasmem, vai gerar um arquivo html com o XML prontinho mostrando todos os passos do que você fez dentro do Photoshop, e não só isso, em alguns casos com links onde vai abrir no Photoshop a ação utilizada… #sensacional

Ele também pode guardar a imagem original e fazer uma comparação com a imagem final, você pode optar se quer ou não essa função e então começar a atividade.

Vamos supor, fiz um button… perceba que no panel do Tutorial Builder fica escrito: CAPTURING… Ele está gravando as ações (Não, não é como um Action).

Terminou? Basta clicar em Done, ele vai perguntar se você quer salvar o Tutorial gerado.

Você vai então salvar o seu PSD

E agora a parte interessante, vai configurar o título e os detalhes que deseja que apareça no seu Tutorial.

Aí é só alegria, o seu tutorial está criado.

“Espera aí Eduardo, onde está o link para baixar essa maravilha? E como vai ficar o resultado final?”

Você pode ver aqui em:
http://labs.adobe.com/technologies/tutorialbuilder

Caso tenha sobra alguma dúvida, assista ao vídeo da Adobe no link indicado, ele explica visualmente como proceder.
Mas acredito que não terá dificuldades, é muito simples de usar, super intuitivo, e uma verdadeira maravilha para nós que queremos compartilhar técnicas de PS.

Espero que tenham gostado, e vamos usar, pois é usando que fará com que a Adobe aprimore mais e mais esse plugin.

Out 28

Html5 – Edição de conteúdo e Web Storage (Exemplo)

Escrito por DClick Team em 1, 2.0, 6, api, AR, blog, browser, C#, carregar, cliente, configuração, Cookie, Design, exemplo, Exemplos, Flex, for, Formação, html, html 5, html5, IE, if, int, novidade, Novidades, O, offline, on, Pessoal, RIA, Ria’s Geral, S+S, Sem categoria, Sun, TAT, Twitter, UI, uint, web @ 10 28th, 2011 | via http://blog.dclick.com.br/pt/ | 1 comentário

Twitter!

Como Html 5 é algo novo para mim e acredito que para muita gente que visita o blog, os meus exemplos irão se limitar a coisas simples, mostrando novidades básicas. No exemplo do post de hoje vou falar sobre duas novidades, a edição de conteúdo e o Web Storage.

Your browser does not support iframes.

Edição de conteúdo nada mais é do que colocar o Html da sua aplicação em modo de design, deixando que o usuário final possa editá-lo como um simples editor de texto, porém sem conhecer nada sobre Html. Essa funcionalidade parece ser algo inútil a primeira vista, porém ela pode se tornar poderosa se formos discutir sobre aplicações html5 offline.

Web Storage tem a função de persistir uma informação dentro de um escopo definido, com um espaço de armazenamento maior do que um cookie (bem maior), e que pudesse ser acessível em qualquer página a qualquer momento sem a necessidade de carregar essa informação de página por página. Essa API é dividida em 2 itens, sessionStorage e localStorage.

sessionStorage
Esse item da API serve para armazenar informação na sessão do cliente que está acessando sua aplicação. É interessante utilizar esse tipo de storage quando o usuário tem informações específicas para a sessão como por exemplo, você deseja abrir 2 janelas da sua aplicação e em uma janela fazer a configuração A e na segunda janela, fazer a configuração B sem que elas tenham interferência uma na outra. Esse tipo de storage também não é persistido, ou seja, quando a sessão fechar, todas as informações são perdidas

localStorage
Esse item da API serve para manter uma informação guardada por tempo indeterminado, ou seja, se o usuário fechar o browser e desligar a máquina e no dia seguinte acessar sua aplicação, ela poderá recuperar qualquer informação que tenha sido armazenada no storage. Para o pessoal que conhece Flex, essa função é idêntica ao SharedObject, pelo pouco que pude testar.

Utilização
A api é bem simples, todo armazenamento é baseado em CHAVE=VALOR e agora vou comentar sobre 3 métodos básicos para sua utilização:

1. setItem(key, value)
Utilizado para adicionar um item ao storage.
localStorage.setItem(‘nome’, ‘DClick’);

2. getItem(key)
Utilizado para recuperar o valor de uma key.
alert(localStorage.getItem(‘nome’)); //resultado ‘DClick’

3. removeItem(key)
Utilizado para deletar o registro referente a key.
localStorage.remoteItem(‘nome’);

Gostaria de ressaltar que os conceitos mostrados aqui são bem simples, apenas como algo introdutório ao assunto. Espero que estejam gostando!

Out 27

User Interface para Apps iOS – Dicas para Designers.

Escrito por DClick Team em 1, 2.0, 4, 6, Android, Aplicativos, app, apple, AR, blog, C#, class, control, demo, Desenvolvimento, Design, designer, Dica, Dicas, Experiências, for, free, IE, if, image, imagens, int, interface, iphone, iTunes, live, Mac, mg, O, on, Partilha, photoshop, problema, problemas, processo, procura, pt, RIA, Ria’s Geral, S+S, Segurança, Sun, tag, TAT, Tema, Teste, Twitter, UI, uint, XP @ 10 27th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

A algum tempo venho me aventurando no estudo de Design para apps, tanto Android quanto iOS. No entando, depois de vastas pesquisas e claro, da prática, nada melhor que ela para nos dar experiência sobre o assunto, resolvi corrigir meu último post sobre o tema.

Nele eu comento sobre a melhor técnica para criar a skin, indicando a resolução de 320 x 480px como a melhor forma. Recordemos:
“Portanto a melhor técnica é criar, obviamente tudo em vetor, na resolução de 320 x 480px, ver se está tudo harmonico, e então só depois redimensionar para o dobro, 640 x 960px. Confie, ficará muito melhor que desenhar diretamente para 640 x 960px, já tive algumas experiências ruins criando diretamente nessa resolução. Deixe para aplicar texturas caso queira faze-lo na resolução de 640, já as bases tem que ser vetorial.”

Acontece que apesar de ser uma técnica boa, utilizada muito lá fora, nada melhor que desenvolvermos o nosso próprio método, que melhor se adapta a nossa realidade.

Um dos grandes problemas que encontrei na criação de interfaces para iOS é a diferença de cores vista no meu Macbook em relação ao meu iPhone4. (o tal retina).
As cores realmente mudam, e o verde ou azul que eu estava vendo no meu Macbook e que achei que estava agradável, misteriosamente mudava de maneira drástica ao abrir a app no iPhone. Confesso que aquilo me irritava a tal ponto que ? a solução empregada por mim era senão exportar imagens de teste para então abri-las no meu iPhone a fim de comparar as cores.

Ok Eduardo, mas não estavamos tratando de resolução? Sim, mas foi procurando a solução de um problema que cheguei na solução de dois…

Pensei naqueles aplicativos para controlar o Mac remotando através do iPhone, mas que fosse por tela compartilhada, fato, iria resolver a questão das cores, mas nada a ver com a questão da resolução.
Porém depois de testar alguns aplicativos cheguei ao Live View, ele não só resolvia esse meu problema pois compartilha a tela, como sua função é exclusivamente ajudar Designers no desenvolvimento das apps, e nem acreditei quando vi que era FREE, e acreditem, pagaria facilmente 5 dólares por ele hoje devido a sua utilidade.

E porque ele resolveu meu problema de resolução? Porque me senti mais tranquilo em desenvolver já no tamanho do retina a fim de poder ver diretamente no iPhone as proporções dos elementos no meu stage.

Resultado, muito mais praticidade e com isso muito mais qualidade no visual da app…

Logo, inverti o processo para o desenvolvimento diretamente em Retina Display, e quando vou exportar no Photoshop eu simplesmente exporto para @2x com 100% de resolução e então exporto sem o @2x, ou seja, 1x, mas com o nome puro da imagem com 50% do seu tamanho.

Ah sim, e a app funciona também para iPad.

Você precisa instalar uma app no seu Mac, que irá liberar o acesso da app que está no seu iPhone ou iPad para ter a visualização no Mac.

http://www.zambetti.com/projects/liveview/

Antes de mais nada você precisa de uma rede wifi onde seu Mac e seu iPhone ou iPad estejam conectados, uma vez com a app baixada no iPhone e iPad, abra primeiro a app que está no seu Mac, do contrário vai aparecer essa imagem:

Agora que aprendeu, e abriu primeiro o Live View no seu Mac, irá aparecer a seguinte mensagem:

Basta selecionar o seu Mac e a imagem que está dentro do retângulo optado (iPhone ou iPad, portrait ou landscape) irá aparecer no iPhone ou iPad da forma como escolheu.

O Live View também permite você colocar uma senha de acesso por questões de segurança.

Ele possui várias configurações, mas são bem simples, você pode rotacionar a tela (portrait ou landscape), optar pelo Retina, inclusive escolher a performance dependendo da sua rede Wifi.

Essa app foi de grande valia para mim, espero que ajude também você que está desenvolvendo ou pensando em desenvolver para iOS.

Out 21

Android 4.0 – Ice Cream Sandwich – SDK

Escrito por Stefan Horochovec em 1, 2.0, 4, 6, Android, Aplicativos, app, AR, bar, BI, blog, C#, class, configuração, Curso, Desenvolvimento, Download, email, err, erro, for, Google, ide, IE, if, image, imagens, int, mg, O, on, padrão, Pessoal, problema, RIA, Ria’s Geral, runtime, S+S, SDK, SmartPhone, TAT, team, Tema, UI, uint, Widget, Widgets, zend @ 10 21st, 2011 | via http://www.horochovec.com.br/blog | Sem comentários

Olá pessoal,

Me deparei com um problema com o Android SDK 4.0 lançado essa sistema e vi que muita gente está sofrendo com o mesmo problema que eu. Um crash inesperado na inicialização do AVD com a seguinte mensagem: “This application has requested the Runtime to terminate it in an unusual way. Please contact the application’s support team for more information.”

Essa semana tivemos o lançamento do Android 4.0 pela Google. Eu particularmente me identifico muito com o Android, possuo a alguns anos smartphones que rodam o sistema e sou instrutor de um curso de Android SDK em parceria com a RIACycle. Não sou um doido varrido pelo Android, mas realmente gosto de todo o seu ecossistema. Pelo fato de eu gostar tanto, desenvolver em cima da plataforma e por ser instrutor do SDK, já fui fazendo o download do novo SDK para conferir um pouco da nova versão Ice Cream Sandwich.

Alguma coisa foi alterada no ADB que algumas das minhas imagens antigas simplesmente não eram mais executadas, sempre dava o mesmo erro na hora de inicializar. Para resolver o problema, eu tive que reduzir a quantidade de memória disponibilizada para a emulação, por padrão, sempre utilizei 1GB, mas só funcionou com 512MB.

Outra situação que está fazendo crash independente da quantidade de memória, é quando eu adiciono na configuração do Hardware a propriedade “Camera Support”, sempre dá crash e não consigo iniciar o emulador.

E por fim, o último problema que eu tive foi com a opção “Launch from snapshot”. Todas as tentivas no Android 4.0 deram erro, sempre tive que iniciar com a opção “Wipe user data” selecionada.

Bom pessoal, tirei algumas telas para que vocês possam conferir a imagem para desenvolvimento. Por enquanto é isso!

Boas vindas

Aplicativos

Widgets

Discador

Navegador

Status do celular

Recebendo ligação

Atendendo Ligação

Ligação Atendida

SMS

Notification Bar

Espero ter ajudado quem está com dificuldades com o novo ADB.

Um abraço e até a próxima

Set 21

RJ – ANALISTA DESENVOLVEDOR FLEX PLENO

Escrito por Eduardo Kraus em AR, C#, Desenvolvedor, economia, Flex, int, lista, Mate, O, on, RIA, Ria’s Geral, super(), TAT, UI, uint, Ved @ 09 21st, 2011 | via http://blog.mxml.com.br | Sem comentários

A Empresa avantiprima (www.avantiprima.com.br) esta com a seguinte vaga aberta.
RJ – ANALISTA DESENVOLVEDOR FLEX PLENO
Escolaridade:
- Ensino Superior Completo ou Cursando em Ci?ncias da Computa??o, Engenharia, Administra??o, Economia, Estat?stica, Matem?tica ou …

« Entradas anteriores | Entradas recentes »