Nov 23

Flash Mobile Day Ed. São Luis

Escrito por Willian Mano em .NET, 1, 2.0, 4, 6, Air, Android, Aplicativos, app, app store, AR, BI, C#, class, Design, err, event, Evento, flash, flash builder, Flex, for, int, interface, internet, mg, mobile, O, on, Palestra, Palestras, problema, problemas, processo, programação, redeRIA, RIA, Ria’s Geral, S+S, TAT, Twitter, UI @ 11 23rd, 2011 | via http://blog.willianmano.eti.br/ | Sem comentários

Flash Mobile Day

No dia 18/11 aconteceu o flash mobile day edição são luis no auditório do cecen – UEMA.

Eu particularmente estou muito satisfeito com o evento, tivemos grandes palestras com conteúdo de alto nível.

Tivemos problemas durante a manhã pois estávamos sem internet para a transmissão das palestras, porém, o evento aconteceu normalmente presencialmente.

As 4 palestras envolveram as áreas de design, programação e marketing. Bom, foi muito show.

A seguir segue o link das apresentações:

Palestra: Design de interfaces para aplicativos móveis.
Palestrante: Eduardo Gibran
Link: http://dl.dropbox.com/u/16067185/palestras_fmd/desingDeInterfaces-Gibran.pdf

Palestra: Proceso de criação. Da escolha da plataforma ? app store.
Palestrante: Willian Mano
Link: http://dl.dropbox.com/u/16067185/palestras_fmd/processoDeCriacao-Willian.pdf

Palestra: Flex para dispositivos móveis
Palestrante: Bruno Araújo
Link: http://prezi.com/klmt7jez4lfv/o-poder-do-flex-para-dispositivos-moveis/

Palestra: Marketing de guerrilha, ações virais e dispositivos móveis: o real e o virtual nas suas mãos.
Palestrante: Rafaela Marques
Link: http://dl.dropbox.com/u/16067185/palestras_fmd/marketing-Rafaela.pdf

Mais uma vez obrigado ? todos que ajudaram para que esse evento fosse possível.

Um gradecimento especial ? todos que apoiaram o evento, em especial ? RIACYCLE que através do Igor Costa nos ajudou a abrilhantar um pouco mais esse evento.

Obrigado a RINO, que, através do Odair Seixas no permitiu realizar essa versão aqui nas terras longiquas de São Luis do Maranhã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 30

Windows Phone Mango – Local Database

Escrito por Alexandre Tadashi em .NET, 1, 2.0, 4, 6, abas, AMF, Aplicativos, app, AR, Arquitetura, arte, Artigo, auto, BI, blog, Blogs, botão, C#, camp, class, classe, classes, cliente, código, collection, cultura, Curso, Cursos, dados, demo, desempenho, Desenvolvedor, Design, designer, Documentação, dotnet, DRE, err, event, Evento, exemplo, Ferramenta, for, Formação, handle, html, ide, IE, if, int, interface, layout, library, Links, linq, Linq to Sql, map, mg, Microsoft, monitor, MSDN, mudanças, O, on, Otimização, Outros, Partilha, processo, pt, rest, RIA, Ria’s Geral, S+S, SDK, server, serviço, silverlight, SQL Server, state, string, TAT, Tecnologia, Tema, template, Treinamento, UI, UX, Ved, vs, window, windows, XAML @ 10 30th, 2011 | via http://alexandretadashi.net/ | Sem comentários

Na versão Mango do Windows Phone, você pode manipular uma base de dados localmente, chamada de local database na documentação oficial, o recurso permite que o desenvolvedor crie aplicativos com registros de dados em tabelas, além de manipular seus registros utilizando o LINQ to SQL.

Uma base de dados local no WP7 fica localizada no Isolated Storage, um local acessível somente pela aplicação corrente, a arquitetura fica conforme a figura abaixo, onde temos a aplicação que contém um DataContext e através de LINQ to SQL, fazemos o acesso a base de dados local no Isolated Storage

Arquitetura Local Database

Para saber mais sobre Isolated Storage acessem os links:

http://msdn.microsoft.com/en-us/library/ff402541(v=vs.92).aspx

http://www.windowsphonebrasil.net/windowsphonebrasil/post/2010/10/08/Salvando-e-restaurando-o-Application-State-no-Windows-Phone-7.aspx

No WP7 as aplicações ficam eram áreas isoladas uma das outras, ou seja, uma aplicação não tem acesso ao Isolated Storage de outra aplicação, portanto até o momento não é possível compartilhar uma base de dados local com diversas aplicações. Diferente de uma base de dados SQL Server, um local database não pode rodar como um serviço continuo, visto que ele é executado somente durante o processo da aplicação.

Você pode criar um local database para manipular uma quantidade de dados razoável utilizando as facilidades de consultas do LINQ to SQL juntamente com o relacionamento de tabelas, similar a uma base de dados comum, o local database é uma implementação do SQL CE para o WP7, permitindo realizar facilmente tarefas com incluir, alterar , excluir e realizar consultas com LINQ.

Até o momento não existe uma ferramenta de designer visual e oficial para criar as tabelas, relacionamentos, etc, com a base de dados local, o que poderia facilitar muito, neste artigo faremos um exemplo simples, somente com uma tabela, porém, em um projeto mais complexo, essa tarefa poderia ser um pouco trabalhosa, uma forma não oficial de criar o modelo seria utilizar o SQL Metal, para mais informação, acessem o Centro de Treinamento Oficial do Windows Phone no MSDN ou através do link : http://windowsphonegeek.com/articles/Using-SqlMetal-to-generate-Windows-Phone-Mango-Local-Database-classes .

Com o SQL Metal podemos criar o Data Context através de um comando e com poucas modificações deixá-lo compatível com o Mango e poupar a codificação manual da criação de tabelas e relacionamentos.

Exemplo de comando do SQL Metal:

%ProgramFiles(x86)%Microsoft SDKsWindowsv7.0ABin>SqlMetal.exe
/code:”C:CaminhoClienteDC.cs” “C:CaminhoClienteDB.sdf”

Outras formas:

http://claudiufarcas.blogspot.com/2011/10/windows-phone-mango-sql-ce-tips-and.html

http://blogs.ugidotnet.org/corrado/archive/2011/06/05/using-local-database-in-wp7-mango.aspx

Nesta primeira parte do artigo vou criar uma base de dados muito simples, com uma tabela somente e um único campo, dessa forma podemos focar em como criar e entender os conceitos envolvidos Vou criar uma base de dados Cliente.sdf, com uma tabela chamada Cliente e um campo chamado Nome.

A primeira classe que vamos criar é a entidade Cliente e decorar com alguns atributos utilizados para a manipulação da base de dados, a classe servirá de apoio para a criação da tabela cliente. Para que você possa inserir os atributos nas propriedades da classe, é necessário adicionar o using System.Data.Linq.Mapping, em seguida adicione o atributo [Table] logo acima da criação da classe e adicione o atributo [Column()] em cada propriedade, na primary key da tabela, personalize com :

[Column(IsPrimaryKey = true, IsDbGenerated = true, DbType = "INT NOT NULL Identity", CanBeNull = false, AutoSync = AutoSync.OnInsert)]

Dessa forma a coluna será criada na tabela como sendo Primary Key, não permitindo registros duplicados e gerando automaticamente um número a cada inclusão. Com a adição do atributo Column() nas outras propriedades, cada coluna correspondente será criado na tabela.

Com os atributos de colunas você pode definir uma série de recursos, para saber quais são os atributos de colunas que você pode utilizar no LINQ to SQL para WP7 acesse o link http://msdn.microsoft.com/en-us/library/system.data.linq.mapping.columnattribute(VS.95).aspx

Um atributo em especial que adiciona uma coluna de versão pode auxiliar no desempenho de grandes atualizações de dados, apresentando uma significativa melhoria na aplicação, é o IsVersion=true, essa otimização é exclusiva para o LINQ to SQL do WP7 e usado internamente para identificar a versão da coluna modificada:

[Column (IsVersion = true)]
_VERSION Binary privado;

Igualmente importantes são os atributos de associações, que permitem realizar o relacionamento entre as tabelas, para mais informações acesse:

http://msdn.microsoft.com/en-us/library/system.data.linq.mapping.associationattribute(v=VS.95).aspx

Exemplo de Associação:

[Association(Storage = "_cliente", ThisKey = "_clienteId", OtherKey = "Id", IsForeignKey = true)]

Código da Classe Cliente:

? ? ?  [Table]

? ? ?  public class Cliente : INotifyPropertyChanged, INotifyPropertyChanging

? ? ?

? ? ? ? ? ? ?  #region INotifyPropertyChanged Members

? ? ? ? ? ? ?  public event PropertyChangedEventHandler PropertyChanged;

? ? ? ? ? ? ?  private void NotifyPropertyChanged(string propertyName)

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanged != null)

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  #endregion

? ? ? ? ? ? ?  #region INotifyPropertyChanging Members

? ? ? ? ? ? ?  public event PropertyChangingEventHandler PropertyChanging;

? ? ? ? ? ? ?

? ? ? ? ? ? ?  private void NotifyPropertyChanging(string propertyName)

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanging != null)

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanging(this, new PropertyChangingEventArgs(propertyName));

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  #endregion

? ? ? ? ? ? ?  [Column(IsPrimaryKey = true, IsDbGenerated = true, DbType = "INT NOT NULL Identity", CanBeNull = false, AutoSync = AutoSync.OnInsert)]

? ? ? ? ? ? ?  private string id;

? ? ? ? ? ? ?  public string Id

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  get

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  return id;

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  set

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (id != value)

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanging("Id");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  id = value;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Id");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?

? ? ? ? ? ? ?  [Column()]

? ? ? ? ? ? ?  private string nome;

? ? ? ? ? ? ?  public string Nome

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  get

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ?  ? ? ? ? ? ? ? ? return nome;

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  set

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (nome != value)

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanging("Nome");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  nome = value;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Nome");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?

? ? ?  }

Em aplicações Silverlight é comum implementar a interface INotifyPropertyChanged para monitorar mudanças nas propriedades da classe , e tirar um melhor proveito do recursos de databinding da tecnologia, para auxiliar o LINQ to SQL, também vamos implementar a interface INotifyPropertyChanging, com ela é possível monitorar quando uma propriedade será modificada e com isso o DataContext é informado e pode identificar as mudanças e melhorar a performance da aplicação.

O Data Context é o local onde definimos o contexto dos dados que servirão para criar a base de dados local, o LINQ to SQL depende do mapeamento entre o modelo de objetos e o esquema da base de dados. Dependendo da complexidade do modelo, esse arquivo pode ser trabalhoso de ser criado manualmente, mas existem formas de utilizar alguma ferramenta para cria-lo, o SQL Metal é uma delas conforme comentado acima no artigo.

Crie uma classe chamada ClienteDataContext , ela vai herdar de DataContext, o DataContext contém diversas propriedades e métodos que auxiliam na manipulação de base de dados, como por exemplo, verificar se uma base de dados existe, criar e excluir uma base de dados, entre outros, mais adiante vamos utilizar o método CreateDatabase() para criar fisicamente a base de dados local no Windows Phone.

A próxima etapa é criar a string de conexão com a base de dados, utilizaremos a palavra chave “isostore” para informar que o arquivo ficará no Isolated Storage, após isso informaremos o nome da base de dados como Cliente.sdf. É na string de conexão que você pode inserir um senha de acesso a base de dados, informar uma cultura específica ou até mesmo criar uma base de dados somente leitura, para mais informações sobre string de conexões para o WP7 acesse http://msdn.microsoft.com/en-us/library/hh202861(v=vs.92).aspx

Por último vamos definir uma tabela Cliente de acesso público e única no DataContext através de public Table Cliente.

No App.xaml.cs da aplicação , localize o construtor da classe e no final adicione o código abaixo, neste momento vamos criar uma base de dados usando o DataContext criado anteriormente, o código verifica se existe uma base de dados e caso não exista ele já cria uma nova base de dados.

using (ClienteDataContext ctx = new ClienteDataContext(ClienteDataContext.DBConnectionString))

? ? ?  if (ctx.DatabaseExists() == false)

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ?  ctx.CreateDatabase();

? ? ? ? ? ? ?

Para finalizar o artigo vou criar uma tela simples em Silverlight, sem se preocupar com o layout, a tela tem um botão chamado “add” que vai adicionar um registro na base de dados e logo abaixo um ListBox chamado “lst”, que está ligado através de databinding a propriedade ItemSource com uma ObservableCollection chamada Items, na propriedade Text vamos mostrar o nome do cliente também ligando através de databinding.


? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  ? Grid.Row="1" Margin="12,0,12,0">
? ? ? ? ? ? ? ? ? ? ?  ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? 
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? 

No constructor do MainPage vamos criar uma instância do DataContext chamado clienteDB :
clienteDB = new ClienteDataContext(ClienteDataContext.DBConnectionString);
No evento ? Loaded da MainPage, realizamos um consulta LINQ to SQL e já adicionamos o resultado em uma ObservableCollections chamada Items, que está ligado ao ItemSource da ListBox, veja como é prático ligar as informações na tela, neste exemplo como o foco é o conceito de local database, o projeto foi criado todo no code-behind da MainPage, mas você poderia criar usando o ViewModel e ligando o ObservableCollection com a View.
var result = from Cliente r in clienteDB.Cliente
select r;
Items = new ObservableCollection(result);
Para mais informações sobre LINQ:
http://msdn.microsoft.com/en-us/library/bb397897.aspx
http://msdn.microsoft.com/en-us/library/bb386976.aspx
http://msdn.microsoft.com/en-us/library/bb386913.aspx
Vamos agora para o código do botão “add” que vai adicionar os registros na base de dados, através do InsertOnSubmit() adicionamos o objeto ao DataContext e através do SubmitChanges(), o objeto é registrado na base de dados, por último, inserimos o objeto na coleção para que seja apresentado na tela.
Cliente c = new Cliente();
c.Nome = txtNome.Text;
clienteDB.Cliente.InsertOnSubmit(c);
clienteDB.SubmitChanges();
Items.Add(c);
? 
Código completo da MainPage:
? ?  public partial class MainPage : PhoneApplicationPage, INotifyPropertyChanged
? ? ?  
? ? ? ? ? ? ? ?  ClienteDataContext clienteDB;
? ? ? ? ? ? ? ?  #region INotifyPropertyChanged Members
? ? ? ? ? ? ? ?  public event PropertyChangedEventHandler PropertyChanged;
? ? ? ? ? ? ? ?  private void NotifyPropertyChanged(string propertyName)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanged != null)
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ?  }
? ? ? ? ? ? ? ?  #endregion
? ? ? 
? ? ? ? ? ? ?  private ObservableCollection _items;
? ? ? ? ? ? ?  public ObservableCollection Items
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  get
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  return _items;
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  set
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (_items != value)
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  _items = value;
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Items");
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  }
? ? ? ? ? ? ?  }
? ? ? ? ? ? ? 
? ? ? ? ? ? ?  // Constructor
? ? ? ? ? ? ?  public MainPage()
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  InitializeComponent();
? ? ? ? ? ? ? ? ? ? ?  clienteDB = new ClienteDataContext(ClienteDataContext.DBConnectionString);
? ? ? ? ? ? ? ? ? ? ?  this.DataContext = this;
? ? ? ? ? ? ? ? ? ? ?  Loaded += new RoutedEventHandler(MainPage_Loaded);
? ? ? ? ? ? ?  
? ? ? ? ? ? ?  void MainPage_Loaded(object sender, RoutedEventArgs e)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  var result = from Cliente r in clienteDB.Cliente
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  select r;
? ? ? ? ? ? ? ? ? ? ?  Items = new ObservableCollection(result);
? ? ? ? ? ? ?  
? ? ? ? ? ? ?  private void add_Click(object sender, RoutedEventArgs e)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  Cliente c = new Cliente();
? ? ? ? ? ? ? ? ? ? ?  c.Nome = txtNome.Text;
? ? ? ? ? ? ? ? ? ? ?  clienteDB.Cliente.InsertOnSubmit(c);
? ? ? ? ? ? ? ? ? ? ?  clienteDB.SubmitChanges();
? ? ? ? ? ? ? ? ? ? ?  Items.Add(c);
? ? ? ? ? ? ?  
? ? ?  }
Links:
Boas Práticas:
http://msdn.microsoft.com/en-us/library/hh286406(v=vs.92).aspx
Mais informações sobre local database no Windows Phone :
http://msdn.microsoft.com/en-us/library/hh202860(v=vs.92).aspx
http://msdn.microsoft.com/en-us/library/hh202876(v=VS.92).aspx
Alterações do esquema da base de dados:
http://msdn.microsoft.com/en-us/library/hh394018(v=VS.92).aspx

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 24

Adobe MAX 2011: Design, Photoshop, UX e…

Escrito por DClick Team em 1, 2.0, 3d, 4, Adobe, Air, Android, app, AR, arte, BI, blog, C#, Catalyst, class, Curso, Cursos, demo, Design, designer, Diversos, efeito, efeitos, empresas, err, event, Evento, Eventos, exemplo, Experiência do Usuário, Ferramenta, flash, Flash Catalyst, Flex, for, futuro, game, html, html5, IE, if, image, imagens, impressão, int, interface, lista, Mercado, mg, mobile, novidade, Novidades, O, on, Opinião, Outros, Palestra, Palestras, photoshop, Projetos, rest, RIA, Ria’s Geral, S+S, screen, Screencast, screencasts, social, Software, Sun, TAT, Tecnologia, Tema, Touch, Twitter, UI, UX, web, XP, zend @ 10 24th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Antes de mais nada, meu enorme agradecimento a diretoria da DClick, Rafael Martinelli, Rogério Martinelli, e Eduardo Melendez, os quais estavam comigo nesse evento da MAX de 2011.

Como alguns aqui já sabem, fui para a MAX porque ganhei a primeira Season do Agon, nossa rede social interna na DClick.

E claro, estou aqui para trazer as minhas primeiras impressões sobre o evento.
Começo dizendo que de infraestrutura não deixa nada a desejar, é um evento de grande porte, muito bacana, e com uma produção de dar inveja. A abertura do evento possui toda a pirotecnia possível, mas vamos deixar essa parte de lado (que você pode conferir facilmente no youtube) para comentar sobre o conteúdo do evento, que é o mais importante.

Sempre reforço que Design é uma matéria que pertence a UX, e não o inverso, tal como outras demais matérias fazem parte do resultado final que é a Experiência do Usuário, e reforçando o que Rafael Martinelli comentou no seu post, a tecnologia é o meio, e ? no Design não é diferente… ? você pode desenvolver uma User Interface com qualquer ferramenta, e para qualquer estrutura, ou seja, qualquer linguagem, Flex, HMTL5, Android, iOS, etc etc… e claro, a ferramenta gráfica mais poderosa do mercado continua sendo o imbatível Photoshop, na minha humilde opinião… Eu sinceramente estava bastante curioso para ver o que a MAX iria trazer nesse sentido, na área de Interfaces, portanto me escrevi nas diversas Sessions de Photoshop, também na de ROX (Return of Experience, ROI pensando no Usuário) e claro, em uma palestra de Flash Catalyst….

Vou começar falando minha impressão sobre as palestras sobre Photoshop, o que vi foi que não se falou muito, ou quase nada de User Interface, e sim foi mostrado técnicas para fotógrafos e outros designers que visam o tratamento de imagem, ou ainda, a produção de imagens detalhadas com 3D e outros efeitos. Confesso que como AppDesigner que sou, me senti meio orfão, mas não é de se admirar, não há profissionais muito empenhados nesse segmento, nem mesmo lá fora, certamente a Adobe fez uma pesquisa do que seria mais atrativo aos participantes da MAX, e acertou em cheio nas palestras voltadas a tratamento de imagens, pois acaba agradando a todos, mesmo AppDesigners como eu se interessam também pelo assunto, pois também utilizamos tais recursos.

Sobre UI não vi nada de novo, nada que eu já não conheça, mas sobre tratamento de imagens, não exatamente no Photoshop, mas por exemplo no Camera Raw e Adobe Bridge, vi recursos que podem ajudar-nos no dia a dia a sermos mais produtivos, sim, muito mais produtivos.. ? e vou abordar as técnicas que vi em posts futuros. Resta dizer ainda, meio que reforçando os comentários do Rafael, que me surpreendi um tempo e vi um pouco de descaso ao Flash, ao Flex nem se fala, praticamente só ouvi falar do mesmo na Session de Catalyst, mas sobre o Flash, depois seu logo apareceu estampado no telão da general session… ? mas o foco era outro, percebi o que não é novidade para ninguém o quanto a plataforma está voltada para games. E claro, o quanto os games estão voltados para o social.

Mas se teve algo que foi comentado em grande escala em todos os eventos, quer seja a general session ou os eventos segmentados, foi sem dúvida o tão badalado nome do momento: HTML5. Acho que você tanto quanto eu sabe as implicações dessa tecnologia, do que ela depende, etc… mas não cabe aqui discutir isso, e sim que o mercado está aceitando o nome, como uma grife, como algo que as pessoas querem estampar. Eu me lembro do termo Web2.0, baladíssimo, as pessoas citam os termos mas não sabem do que se trata realmente.

Agora chega de blá blá blá e vamos a um resumo da situação.

Photoshop:

A MAX trouxe profissionais que falaram de muitas novidades, não dentro do software, mas extensões, aquele tipo de ferramenta que te ajuda no dia a dia. Se teve algo de novo para mim no Photoshop foi sobre uma palestra de compactação de arquivo JPG, confesso que ouvi coisas que me surpreenderam, e é de uma utilidade absurda. Futuro Post

UX:

Nada de novo, mas o óbvio, que avaliar as possibilidades do estudo centrado no usuário pode trazer um retorno muito maior ao investimento feito nos projetos. Não é novo, mas a maioria das empresas não aplica essa estratégia… ? UX também é um termo que está já meio que saturado, todo mundo fala, ninguém sabe o que é, mas é bonito de se citar… ? Não é bem assim que deveria ser, mas ao que parece, a Adobe também está fazendo o seu papel em educar os seus profissionais e evangelistas sobre esse termo, o que é, e o quanto é importante nos projetos. Logo, foi positivo ver esse posicionamento da empresa sobre o assunto. ROX, Futuro post

Design:

A MAX não é o que podemos dizer de um evento propriamente voltado a esse segmento, para isso existe um evento só sobre Photoshop, onde além de se tratar do software em si, se fala sobre os diversos aspectos do Design. Mas resta dizer que estava impecável o tratamento e cuidado com a matéria, quer seja nos games que vi, aplicações, ou citações nas palestras.

Novidade:

A Adobe trouxe alguns tipos de apps para mobile (Tablet mesmo), que pasmem (até parece.. rs) são para Androids primeiramente, e em breve vão sair para iOS.
Você pode encontrá-las aqui: http://www.adobe.com/products/touchapps.html

Aos poucos estarei trazendo as novidades referente aos temas que abordei em posts ou screencasts. Acompanhem o Blog!!!

Out 24

GDD – Google Developer Day

Escrito por DClick Team em 1, 2.0, 3d, 4, 6, Android, Aplicativos, app, AR, arte, bar, BI, blog, bons tempos, C#, chrome, class, comunidade, Curso, dados, demo, Desenvolvedor, desenvolvedores, Desenvolvimento, Desenvolvimento de Software, developer, engine, err, event, Evento, Eventos, exemplo, Ferramenta, for, framework, futuro, game, Google, hospedagem, html, html 5, ide, IE, if, image, int, interface, Java, jogo, Jogos, lista, Mercado, mg, mobile, NaN, novidade, O, on, padrão, Palestra, Palestras, Pessoal, problema, procura, produtividade, programação, referencia, RIA, Ria’s Geral, S+S, serviço, Serviços, site, SmartPhone, Software, tag, TAT, Tecnologia, Teste, transição, Twitter, UI, usabilidade, Ved, Vídeo, web @ 10 24th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Impressões sobre o Evento do Google para Desenvolvedores

São Paulo foi escolhida como a primeira cidade para cediar o Google Developer Day, e não foi por acaso. O Google deixou bem claro em seu KeyNote que está acreditando muito no mercado brasileiro no que diz respeito a desenvolvimento de software, e não é uma mera crença, mas sim um argumento baseado em dados que o CTO do Google faz questão de mostrar pra todo mundo em sua palestra. Dentre tais números está a marca impressionante de 500.000 (quinhentas mil) ativações de dispositivos Android no mundo por dia e crescendo, sendo que um dos maiores mercados é o Brasil.

Para participar do GDD era preciso se inscrever no site, e resolver uma provinha com um problema simples de programação. Acertando as questões da provinha, suas chances de ser convidado aumentavam consideravelmente. E foi assim que eu fui convidado.
Trata-se de um evento voltado principalmente para desenvolvedores, com brindes, comida e Wi-Fi de graça, ou seja, o paraíso para muito Nerd entusiasta Google. Com direito a tendinhas e logos do Google espalhados por todo Hall de eventos do Hotel Sheraton.
Fiquei espantado com a quantidade de pessoas, e principalmente com a quantidade de pessoas usando algum smartphone top de linha (com Android claro) no mesmo ambiente. Ambiente esse que tocava música 8 bits dos video games antigos (bons tempos… =) ). E para começar o evento e dar início a maratona de palestras, o CTO do Google pessoalmente ministrou o KeyNote.
O KeyNote deixou todo mundo bem curioso sobre o que estava por vir ao longo do dia nas palestras separadas por tracks como Android, Google AppEngine, Google Chrome e talvez o mais esperado Html 5.

Android

Nada de muito novo com as palestras sobre Android. O pessoal do Google fez questão de manter o suspense sobre qual seria a versão do novo Android (Ice Cream Sandwich), mas que agora já foi revelado que será a 4.0.
Foram feitas algumas palestrar sobre usabilidade de Apps para Android, e passado bem por cima as features novas da plataforma, dentre elas o que acredito fosse o mais esperado é a integração total entre celulares e tablets, ou seja, o mesmo apk para ambos os dispositivos.
Para tornar fácil tal integração, foi adicionado o conceito de Fragment, que nada mais é do que uma porção específica da interface do dispositivo, que varia de acordo com o tamanho da tela. Por exemplo um tablet, pode possuir 3 Fragments padrão, sendo um uma barra de tarefas, outro uma listagem e um uma área de trabalho todos mostrados ao mesmo tempo, mas a mesma aplicação em um celular iria do Fragment de listagem para o Fragment com a área de trabalho por meio de uma transição, pois não cabem os 3 fragments na tela ao mesmo tempo.
Falou-se muito de In App Billing, ou seja, compra de artefatos dentro das próprias aplicações e não diretamente no market. Foram mostrados números bem convincentes, como por exemplo: do top 10 de aplicações mais rentáveis na AppMarket, 9 usam In App Billing. Números no mínimo tentadores para arriscar com a tecnologia.
Acredito que o Google tem muito mais novidade guardada para o Android, mas não falaram nada no GDD, porque o foco do evento foi outro, como veremos.

Google AppEngine

A procura pelas palestras sobre AppEngine foi muito grande, tanto que não consegui entrar em uma delas pois a sala lotou logo depois do anúncio do começo do evento.
O Google definitivamente acredita que seu Cloud é o futuro no que diz respeito a hospedagem de serviços para as Apps Mobile. O foco principal no GDD foi mostrar como que é fácil desenvolver para a AppEngine todos os tipos de aplicativos, incluindo jogos (foi reservada uma palestra apenas para falar de jogos usando a AppEngine).
Acredito que a intenção do Google é difundir mais o uso da AppEngine aqui no Brasil. Acredito que apesar do crescimento que foi obtido, eles percebem que o crescimento pode ser muito maior. Não acompanhei muito o track sobre AppEngine, então não consigo entrar muito em detalhes sobre o que mais foi abordado.

Google Chrome

Eu não esperava que fosse ser dada tanta atenção ao Google Chrome como foi dada no GDD.
Em todas as palestras o Google Chrome era referenciado como principal porta de entrada para a Web e as novas tecnologias. Foram apresentadas ferramentas de produtividade e desenvolvimento para criar aplicativos específicos do Google Chrome.
Acredito que o Google está preparando terreno, e já quer ter em mãos muitos aplicativos compatíveis com o Google Chrome quando chegar a hora de lançar o Chrome OS. E o discurso deles é muito convincente para os desenvolvedores. Eu ouvi muita gente impressionada com as possibilidades e facilidades de desenvolver aplicativos Chrome.

Html 5

Html 5 foi a estrela do evento. Não tinha uma pessoa que os olhos não brilhavam ao ver o trailer de Era do Gelo em 3D no Youtube, ou alguns avatares dançando conforme a música que tocava no ambiente de maneira dinâmica. E todo mundo ficou impressionado quando descobriu que todos os slides de todas as palestras estavam sendo passados no Chrome, e foram feitos em Html 5.
Foram mostradas muita features de Html 5 que ainda estão em teste, e que não necessariamente irão dar certo, mas a idéia não era conseguir algum tipo de vantagem, e sim mostrar o potencial do que está por vir.
Foi apresentado um framework muito interessante em Java: PlayN!. Uma biblioteca para construir jogos que podem ser jogados em Html 5, Android ou até mesmo Java nativo.
Muitas melhorias com tratamento de áudio e vídeo foram mostradas, e do jeito com que os palestrantes demonstraram, é difícil não acreditar que Html 5 ditará o ritmo das aplicações Web em um futuro próximo.

Espero que eu tenha despertado a curiosidade de alguns sobre as tecnologias do Google e da Comunidade que estão por vir. E de uma coisa eu estou convencido, preciso conhecer mais Html 5 .

Por @Gust4v0_H4xx0r

Out 24

GDD – Google Developer Day

Twitter!

Impressões sobre o Evento do Google para Desenvolvedores

Android

Google AppEngine

Google Chrome

Html 5

Por @Gust4v0_H4xx0r

Jun 27

Princípios de Projeto OO

Escrito por Edgard Davidson em 1, 3.5, 4, 6, AR, BI, blog, C#, Curso, Design Patterns, IE, int, interface, O, on, Pessoal, POO, RIA, Ria’s Geral, S+S, Software, UI @ 06 27th, 2011 | via http://edgarddavidson.com | Sem comentários

Ol? Pessoal.

J? est?o dispon?veis no blog do curso de p?s gradua??o em Engenharia de Software Centrada em M?todos ?geis todos os post referente aos Princ?pios de Projeto OO.

SAP – Stablility and Abstract Principle – Princ?pio da Abstra??o e Estabilidade
CCP – Common Closure Principle
ADP – Acyclic Dependencies Principle – Princ?pio da Depend?ncia Ac?clica
REP – Reuse release equivalence principle – Princ?pio da Equival?ncia de Reuso/Vers?o
OCP – The Open Close Principle – Princ?pio aberto/fechado
SDP –Stable Dependencies Principles – Princ?pios das Depend?ncias Est?veis
CRP – The Common Reuse Principle – Princ?pio da Reutiliza??o Comum
LOD – Law Of Demeter – Lei de Demeter
DIP – The Dependency Inversion Principle – Princ?pio da Invesr?o da Depend?ncia
SRP – Single Responsability Principle – O Princ?pio da Responsabilidade ?nica
LSP – The Liskov Substitution Principle – Princ?pio da Substitui??o de Liskov
ISP – The Interface Segregation Principle – Princ?pio da Segrega??o de Interfaces

Boa leitura!

Jun 17

Novidades da versão Mango – Parte 1

Escrito por Alexandre Tadashi em .NET, 1, 2.0, 3.5, 4, 6, Air, api, Aplicativos, AR, arte, Artigo, audio, auto, back, Banco de Dados, Beta, BI, bing, Blend, botão, browser, busca, C#, código, control, Controles, Curso, Cursos, dados, demo, Desenvolvedor, desenvolvedores, Desenvolvimento, developer, Dica, Diversos, Download, DRE, empresas, err, event, Evento, Eventos, Excel, exemplo, Exemplos, explorer, expression, Expression Blend, facebook, Ferramenta, for, framework, Geral, html, html5, ide, IE, if, image, imagens, int, interface, internet, library, linkedin, lista, Livro, mg, Microsoft, MIX, mobile, monitor, motion, movimento, MSDN, mudanças, NaN, novidade, Novidades, O, on, Outros, Partilha, processo, progress, Redes Sociais, rest, RIA, Ria’s Geral, S+S, serviço, silverlight, Silverlight 4, SmartPhone, Software, TAT, Tecnologia, Tema, tool, Twitter, UI, UX, Ved, Vídeo, Vídeos, Visual Studio, Visual Studio 2010, vs, window, windows, Xna, XP @ 06 17th, 2011 | via http://alexandretadashi.net/ | Sem comentários

É grande a expectativa pelos desenvolvedores .net para a chegada e comercialização do Windows Phone no Brasil, a plataforma chega bem completa e robusta, atendendo diversas necessidades dos usuários e desenvolvedore e permitindo a criação de aplicativos utilizando as mais modernas tecnologias Microsoft.
Apresentada no evento MIX 11 da Microsoft, a versão com o codinome Mango, chegou com mais de 500 novidades, são tantos recursos que não é possível cobri-los em um único artigo, podemos destacar algumas melhorias como sendo essenciais para o crescimento da plataforma, como o suporte a multitarefa, a atualização da versão do Silverlight para o Silverlight 4 e a atualização do Browser para a versão do Internet Explorer 9 com suporte ao HTML5, essas são sem dúvidas grandes mudanças tanto para o desenvolvedor como para o usuário.

Para os desenvolvedores foram diversas melhorias e para os usuários não foi diferente, houve uma melhor integração com o Skydrive, possibilitando compartilhar fotos por e-mail e SMS, podemos também compartilhar vídeos realizando o upload em background, navegar pelas pastas no Skydrive, realizar pesquisas de conteúdo, entre diversos outros recursos de integração com esse excelente serviço da Microsoft.

Outro recurso interessante é o Bing Vision, que é uma ferramenta que usa a câmera do telefone para reconhecer imagens, por exemplo, ao focar a capa de um determinado livro ele apresenta uma lista de resultados onde o livro é citado, já o Bing Áudio, é um mecanismo inteligente de busca de áudio, ele pode até reconhecer uma música que está sendo tocada e apresentar resultados sobre a música, esses são somente alguns exemplos, mas houve melhorias e atualizações em diversos HUBs, sensores e recursos do sistema operacional, além de uma forte integração com redes sociais como facebook, twitter e linkedIn.

As ferramentas de desenvolvimento para a versão Mango já estão disponíveis para download em versão Beta, muitas informações e recursos podem ficar diferentes na versão final, mas geralmente são mudanças pequenas. Com as ferramentas já é possível criar e testar todo o aplicativo com o Visual Studio 2010 e utilizar todo o poder do emulador que está integrado totalmente com o Expression Blend for Windows Phone ou com o Visual Studio 2010.

Download: Windows Phone Developer Tools 7.1 Beta tools

Os programadores Visual Basic .net agora podem criar aplicativos para o Windows Phone tanto em Silverlight como no XNA Framework, o Visual Basic é totalmente integrado com o Windows Phone Developers Tools 7.1 Beta, não sendo necessário instalar nenhuma ferramenta a parte. No Mango houve melhorias internas no sistema operacional que resultou em uma melhor performance na execução dos aplicativos em geral, alguns recursos agora rodam em threads background, deixando a interface do usuário com uma resposta mais rápida, essas melhorias são refletidas em sua aplicação e você não precisa codificar nada para usar desses benefícios, além dessas melhorias internas ouve também a inclusão de recursos essenciais para a criação de aplicações, como o suporte a OData e a inclusão de um banco de dados local.

O Windows Phone Marketplace também está em constante crescimento, com poucos meses de lançamento, a loja de aplicativos do Windows Phone 7 é constantemente atualizada com dezenas de novos aplicativos, o número de desenvolvedores e aplicativos podem aumentar significativamente com está atualização com codinome Mango, é previsto que o Marketplace esteja disponível para que os usuários possam comprar aplicativos em um total de 35 países, inclusive o Brasil e com suporte a 16 novas línguas, contando com o Português do Brasil.

Se você é um desenvolvedor da plataforma Microsoft .net e ainda não começou a desenvolver para o Windows Phone, é importante saber que a curva de aprendizado não é muito grande, principalmente se você já tem conhecimento na plataforma Silverlight ou XNA, o Windows Phone pode se tornar competitivo nos próximos anos, principalmente com a entrada e comercialização de equipamentos pelas operadoras no Brasil, somado com a recente parceria com a Nokia, umas das mais importantes empresas do setor, e a compra do Skype pela Microsoft, que vai trazer esse aguardado software para a plataforma .net, além de novas parcerias com fabricantes, tudo isso está fortalecendo a tecnologia mais recente da plataforma mobile da Microsoft.

Modelo de execução – Estado dormant

Houve uma pequena modificação no modelo de execução de aplicativos no Windows Phone Mango, nesta versão temos um novo estado da aplicação chamado dormant, para entendê-lo, vamos relembrar como funciona o ciclo de vida de uma aplicação no Windows Phone, temos quatro eventos que são acionados como apoio durante o uso do aplicativo, são eles, launching, closing, activated e deactivated, e junto com esses eventos podemos ter dois estado da aplicação, running e tombstoned, e para auxiliar com a manipulação de estados podemos utilizar os métodos OnNavigatedTo e OnNavigatedFrom. Quando você inicia uma aplicação, por exemplo, através do botão Start clicando em algum Tile, automaticamente uma nova instância do aplicativo será criada na memória, neste momento o evento Launching é acionado, ou seja, sempre que uma nova instância é criado, o evento Launching será chamado, neste evento temos que evitar a utilização de códigos que possam ser demorados e atrapalhar a experiência de uso do usuário da aplicação, além de que o Windows Phone Marketplace também informa limites de tempo para que a sua aplicação inicie. Após o evento Launching ser acionado, a sua aplicação entra em um estado chamado Running, neste momento sua aplicação está em execução e você poderá realizar tarefas e o usuário poderá navegar em sua aplicação. Neste momento se o usuário apertar o botão Start, por exemplo, ele estará acionando um evento chamado Deactivated e sua aplicação deverá salvar qualquer estado do aplicativo que você deseja restaurar caso o usuário retorne para sua aplicação através do botão Back, é neste ponto que houve um mudança com a versão Mango, agora existem dois
estados utilizados neste processo, o dormant e o tombstoned, sua aplicação entre em estado dormant antes de entrar em tombstoned, o que não acontecia na versão anterior, onde o aplicativo entrava direto em tombstoned. Quando o usuário navega para fora da sua aplicação , o Windows Phone coloca o aplicativo no estado dormant, neste momento todo o processamento, ou seja, todas as threads, são paradas, mas a aplicação ainda está na memória do aplicativo, este estado permite retornar a aplicação utilizando o máximo de performance, pois não é necessário recriar qualquer estado pois todos foram preservados. Se um aplicativo está no estado dormant e o usuário iniciar outro aplicativo, o sistema operacional vai verificar se esse novo aplicativo iniciado precisa utilizar mais memória do que o device disponibiliza como livre no momento,se isso ocorrer, a sua aplicação poderá ser escolhida para sair do estado dormant e entrar no estado tombstoned.

Mais informações : http://msdn.microsoft.com/en-us/library/ff817008(v=vs.92).aspx

Background Agents

Com os Background Agents podemos realizar algumas tarefas mesmo que a aplicação não esteja em execução, existem duas formas de realizar esse agendamento de tarefas, através de scheduled notifications ou scheduled tasks.

Uma scheduled notification é um aviso, que pode ser do tipo Alarm ou Reminder, o tipo Alarm permite que você especifique um arquivo de som para tocar quando a notificação é acionada, o tipo Reminder, você pode especificar uma URI para sua aplicação, quando o usuário clicar na notificação, a aplicação será executada e a URI será passado com parâmetro.

Já um Scheduled Task permite que você execute uma tarefa em background, mesmo quando a aplicação não está sendo executada, cada aplicação pode ter um único agente, que será registrando em sua aplicação e você pode especificar o tipo de scheduled que será executado, existem dois tipos, o PeriodicTask e o ResourceIntensiveTask, o primeiro é indicado para tarefas onde o tempo de execução será curto, como por exemplo, armazenar uma pequena quantidade de dados, e pode ser utilizado regularmente, já o ResourceIntensiveTask, tem sua utilização mais rara, pode ser utilizado para tarefas mais demoradas e que utilizam mais dos recursos do smartphone, com por exemplo a sincronização de um grande volume de dados.

File Transfers

Na versão mango temos disponíveis algumas APIs para a manipulação de uploads e downloads de arquivos no Windows Phone, esses arquivos podem ser enfileirados e executados em segundo plano (background), o Windows Phone fornece meios de verificar o status da transferência dos arquivos e ainda fornece meios de monitorar o progresso do download ou upload.

Áudio Background

Tocar um arquivo de som rodando em background, mesmo que a aplicação não esteja em foreground, se tornou uma tarefa fácil e gerenciada pelo sistema operacional, o suporte ao áudio em background é fornecido pelo namespace Microsoft.Phone.BackgroundAudio, com ele é possível acionar uma música e mesmo que o usuário inicie outros aplicativos, a música continuará em execução e o usuário ainda terá o acesso aos controles de aumentar e diminuir o volume.

Mais informações: http://msdn.microsoft.com/en-us/library/hh202978(v=vs.92).aspx

Sensores

Os smartphones estão ficando cada vez mais sofisticados e uma série de sensores estão sendo disponibilizados com esses modernos aparelhos, na versão mango temos disponível além do conhecido acelerômetro, mais dois sensores igualmente importantes, como a bússola e o giroscópio.

A bússola permite obter o ângulo pelo qual o smartphone é girado em relação ao polo magnético da terra, sua aplicação pode realizar a leitura dessas forças magnéticas e utilizar para realizar alguma ação, o sensor bussola não é um item considerado obrigatório para os fabricantes de equipamentos utilizarem com o Windows Phone, portanto se a sua aplicação for utilizar o recurso , ele precisa informa-lo e ainda verificar se o recurso está presente através de recursos do sistema operacional. Eventualmente a bussola pode ficar descalibrada, os smartphones com o sensor possuem recursos para a calibração da bussola, onde um movimento em formado de infinito é realizado.

O Giroscópio é outro sensor disponível para o desenvolvedor utilizar em suas aplicações, com ele podemos medir a velocidade de rotação do smartphone dos eixos X, Y e X. Todos os equipamentos com Windows Phone possuem o acelerômetro como sensor obrigatório, o acelerômetro consegue medir a aceleração do smartphone em movimentos mais intensos, no caso de uma simples e leve rotação de eixos, esses valores não podem ser lidos através do acelerômetro, já com o giroscópio é possível obter os valores quanto a velocidade de rotação do celular.

Juntos, o giroscópio, acelerômetro e a bussola, forma um conjunto completo que pode ser utilizado para formar um sofisticado sensor de movimentos, para simplificar essa integração, a versão Mango disponibiliza através do Microsoft.Devices.Sensors.Motion, um conjunto de recursos que facilitam a leitura dos resultados gerados pelos sensores para que você possa utilizar em sua aplicação.

continua…

« Entradas anteriores | Entradas recentes »