Desarrollo Mobile en Delphi Academy

La agenda de este semestre de Delphi Academy se centra principalmente en el desarrollo de aplicaciones móviles.

Empezamos el semestre hablando sobre las mejores prácticas para la interfaz de usuario, con el episodio “Aplicaciones móviles: Aciertos/Errores en el UI“, el cual fue al aire en 11/08:

Este episodio tiene algunos ejemplos interesantes, los cuales se pueden encontrar en nuestro repositorio Git: https://github.com/flrizzato/DelphiAcademy/tree/master/30-MobileYesNo

En la secuencia hablamos sobre los Sensores disponibles en los dispositivos móviles, los cuales deben ser ampliamente empleados en sus aplicaciones. Este episodio, llamado “Aplicaciones móviles: Sensores y Dispositivos” fue al aire el 25/08:

Los ejemplos de esta presentación son básicamente los mismos que acompañan al producto (Delphi y C++ Builder), de todos modos están organizados en nuestro repositorio también: https://github.com/flrizzato/DelphiAcademy/tree/master/31-MobileSensors

Esta serie sobre móviles se inició en el primer semestre de este año, con tres episodios enfocados en mostrar los conceptos básicos del desarrollo FireMonkey (“Empezando con Aplicaciones Móviles en Delphi y C ++ Builder”, “Aplicaciones Móviles: Buenas Prácticas de UI” y “Aplicaciones Móviles: Acceso a Datos“). Si no los ha encontrado, vaya directamente a este enlace: http://embt.co/AcademyLA-replay

Para la próxima semana, vamos a intentar poner todo este aprendizaje en un ejemplo integrado, el cual podrá ser reutilizado como base para nuevos proyectos. ¡Entonces nos vemos el viernes!

ps: No se olvide de inscribirse => http://embt.co/AcademyLA

 

Advertisements

Desenvolvimento Mobile no Delphi Academy

A agenda deste semestre do Delphi Academy está focada principalmente em desenvolvimento de aplicações mobile.

Iniciamos o semestre falando de boas práticas para a interface do usuário, com o episódio “Aplicações Mobile: Acertos/Erros na UI“, o qual foi ao ar em 08/08:

Este episódio possui alguns exemplos interessantes, os quais podem ser encontrados em nosso repositório Git: https://github.com/flrizzato/DelphiAcademy/tree/master/30-MobileYesNo

Na sequência falamos sobre os Sensores disponíveis nos dispositivos móveis, os quais devem ser amplamente empregados em suas aplicações. Este episódio, chamado de “Aplicações Mobile: Sensores e Devices” foi ao ar em 22/08:

Os exemplos desta apresentação são basicamente os mesmos que acompanham o produto (Delphi e C++ Builder), de qualquer maneira eles estão organizados em nosso repositório também: https://github.com/flrizzato/DelphiAcademy/tree/master/31-MobileSensors

Esta série sobre mobile teve inicio ainda no primeiro semestre deste ano, com três episódios focados em mostrar os conceitos básicos do desenvolvimento FireMonkey (“Iniciando com Aplicações Mobile em Delphi e C++ Builder”, “Aplicações Mobile: Boas Práticas de UI” e “Aplicações Mobile: Acesso a Dados”). Caso não os tenha encontrado, vá direto a este link: http://embt.co/AcademyBR-replay

Para a próxima semana, vamos tentar colocar todo este aprendizado em um exemplo integrado, o qual poderá ser reutilizado como base para novos projetos. Então nos vemos na terça-feira!

ps: não deixe de se inscrever => http://embt.co/AcademyBR

 

Embarcadero Report from the TDC 2017 in São Paulo

In the week of 18 to 22 of July we had the biggest developers conference from the Latin America, popularly known as The Developer’s Conference.

Embarcadero, as a key player in this market, was present there, not only as a Diamond Sponsor, but also with an entire track about Delphi and C++ Builder!

Nenhum texto alternativo automático disponível.

During these days we had the opportunity to show off the power of our multi-device strategy, as well our new backend support for Linux and the Windows 10 integration. All the presentations were organized and presented by our MVPs and community of users:

Inline image 1

Considering the entire week, more than 3k developers passed by the event, as well by our booth, where we did tons of demos and discovered developers surprised with the power that Delphi has nowadays!

You can find some thousand of pictures in the event fan page on Facebook, I’m pretty sure you can find us there!

Comenzando con el desarrollo móvil con Delphi y C++ Builder: La nueva serie de episodios en Delphi Academy

Iniciamos recientemente una serie de episodios enfocados en Mobile en Delphi Academy.

En el 23/06, hablamos sobre cómo iniciar con mobile en RAD, Delphi y C ++ Builder (Empezando con Aplicaciones Móviles en Delphi y C++ Builder). Si ha perdido esta introducción, el vídeo está en nuestra lista de reproducción. En este episodio en particular no hay ejemplos a bajar, pero las diapositivas se pueden encontrar en nuestro GitHub, así como los ejemplos de todos los demás episodios.

Hoy (30/06) el tema fue relacionado con buenas prácticas en la construcción de interfaces para aplicaciones (Aplicaciones Móviles: Buenas Prácticas de UI), y el feedback fue excelente. A juzgar por el nivel de las preguntas, tenemos usuarios creando aplicaciones extremadamente avanzadas con Delphi y C++ Builder para iOS y Android! Como de costumbre, la lista de reproducción y GitHub ya están actualizados con el vídeo de hoy y ejemplos y diapositivas.

mobile

En el próximo episodio, programado para ser transmitido en 14/07, hablaremos sobre acceso a datos en el móvil, y entonces dispondremos una nueva agenda con nuevos episodios. Entre los temas en pauta, nos gustaría avanzar más con la cuestión de la UI y también acceder a datos, ya que estos son asuntos con muchas posibilidades y variaciones, por lo que merecen más tiempo.

Durante esta planificación, usted está invitado a enviar sugerencias de temas a ser abordados, simplemente deje su comentario en este post y le aseguro que el mismo será evaluado.

¡Abrazos y hasta la próxima Delphi Academy!

 

Série de Episódios sobre Mobile no Delphi Academy

Iniciamos recentemente uma série de episódios focados em Mobile no Delphi Academy.

Em 13/06, falamos sobre como iniciar com mobile no RAD, Delphi e C++ Builder (Iniciando com Aplicações Mobile Delphi e C++ Builder). Caso tenha perdido esta introdução, o vídeo está em nosso playlist. Neste episódio em particular, focado em conceitos, não há exemplos a serem baixados, mas os slides podem ser encontrados em nosso GitHub, bem como os exemplos de todos os demais episódios.

Hoje (27/06), o assunto foi relacionado com boas práticas na construção de interfaces para apps (Aplicações Mobile: Boas Práticas de UI), e o feedback foi excelente. A julgar pelo nível das perguntas, temos usuários criando aplicações extremamente avançadas com Delphi e C++ Builder para iOS e Android! Como de costume, o playlist e GitHub já estão atualizados com o vídeo de hoje e exemplos.

mobile

Mobile com Delphi e C++ Builder

 

No próximo episódio, programado para ser transmitido em 11/07, falaremos sobre acesso a dados no mobile, e então disponibilizaremos uma nova agenda com novos episódios. Dentre os assuntos em pauta, gostaríamos de avançar mais com a questão da UI e também acesso a dados, já que estes são assuntos com muitas possibilidades e variações, portanto merecem mais tempo.

Durante este planejamento, você está convidado a enviar sugestões de tópicos a serem abordados, simplesmente deixe seu comentário neste post e garanto que o mesmo será avaliado.

Abraços e até o próximo Delphi Academy!

Windows 10 Store, Android, iOS, OS X, Linux: recursos para migrar sua aplicação Delphi/C++ Builder e suportar TODAS as plataformas (parte 2)

Na primeira parte deste artigo (aqui) exploramos os principais desafios na migração de projetos Delphi/C++ Builder, listamos alguns tópicos que vamos tratar ao longo de uma série de artigos, e iniciamos o entendimento da parte teórica sobre Unicode.

Neste post vamos retomar o assunto Unicode, porém de um ponto de vista mais técnico, buscando compreender as alterações que são necessárias (ou não) em um projeto.

Vale ressaltar que o suporte a Unicode foi introduzido no Delphi/C++ Builder 2009, portanto, projetos compilados em versões 2009+ não devem sofrer qualquer impacto no tocante a Unicode durante um processo de migração.

O que mudou?

A partir da versão 2009 (inclusive), o tipo String passou a ser definido pelo tipo UnicodeString, que é uma string UTF-16. Da mesma forma, o tipo Char é agora WideChar, um tipo de caractere de dois bytes e PChar é um PWideChar, um ponteiro para um Char de dois bytes.

O ponto significativo sobre as alterações a esses tipos de dados básicos é que, no mínimo, cada caractere é representado por pelo menos um “code unit” (dois bytes), e às vezes mais.

Coincidente com essas mudanças é que o tamanho de uma sequência de caracteres, em bytes, não é mais igual ao número de caracteres na sequência de caracteres. Da mesma forma, um valor do tipo Char não é mais um único byte; são dois bytes.

Opção #1: Mantenha tudo em seu lugar

Uma das opções com relação a Unicode é simplesmente não fazer nada. Isso mesmo… ou na verdade… quase isso. Nas versões anteriores a 2009, o tipo String era então mapeado para AnsiString. Logo, reverter as declaração de String para AnsiString pode ser uma alternativa para uma migração rápida – caso você não necessite suportar caracteres estendidos. O que precisa ser feito, na verdade, é converter declarações String para AnsiString, Chars para AnsiChars e PChars para PAnsiChars.

Para auxiliar nesta tarefa, um membro do Australian Delphi Users Group (ADUG) – Roger Connell – criou um convertor para pesquisar seus arquivos  Delphi (.pas e .dpr) e fazer as conversões, se essa abordagem funciona para você:http: /www.innovasolutions.com.au/delphistuf/ADUGStringToAnsiStringConv.htm

Obviamente, mesmo reduzindo as mudanças ao mínimo, testar e validar sua aplicação previamente a enviá-la para um ambiente de produção, continua sendo uma recomendação mandatória.

Opção #2: Abraçando o Unicode de vez

O Unicode incentiva o uso de alguns novos termos. Por exemplo, a idéia de “caractere” é um pouco menos preciso no mundo do Unicode do que você pode estar acostumado. No Unicode, o termo mais preciso é “code point”. A partir da versão 2009, o SizeOf (Char) é 2. Dependendo da codificação, é possível que um determinado caractere ocupe mais de dois bytes. Estas sequências são chamadas de “Surrogate Pairs“. Assim, um “code point” é um código exclusivo atribuído a um elemento definido pelo Unicode.org. Mais comumente isso é um “caractere”, mas nem sempre.

String agora é igual a UnicodeString, logo suas suposições anteriores sobre o tamanho em bytes de uma matriz de caracteres ou sequência de caracteres podem agora estar incorretas.

Procure qualquer código que:

  • Pressupõe que SizeOf (Char) é 1.
  • Pressupõe que o comprimento de uma sequência de caracteres é igual ao número de bytes na sequência de caracteres.
  • Diretamente manipula sequências de caracteres ou PChars.
  • Grava e lê strings em algum tipo de armazenamento persistente.

As duas suposições listadas aqui primeiro não são verdadeiras para Unicode, porque para Unicode SizeOf (Char) é maior que 1 byte, e o comprimento de uma sequência de caracteres é metade do número de bytes.

Além disso, o código que grava ou lê a partir de armazenamentos persistentes precisa garantir que o número correto de bytes estão sendo gravados ou lidos, uma vez que um caractere pode não ser mais capaz de ser representado como um único byte.

Compreendidas estas alterações, temos um sem números de ótimos documentos e tutoriais para se aprofundar no tema Unicode, os quais estou listando abaixo, porém gostaria de chamar a atenção para uma ferramenta em especial, o Unicode Statistics Tool. Este pequeno utilitário tem a capacidade de revisar seu código e dizer onde e o que você provavelmente vai ter que mudar. Obviamente, trata-se de um auxiliar e não uma ferramenta mágica, mas ajudará muito!

Recursos Adicionais

Windows 10 Store, Android, iOS, OS X, Linux: recursos para migrar sua aplicação Delphi/C++ Builder e suportar TODAS as plataformas!

Introdução

O suporte para múltiplas plataformas tem motivado muitas companhias a migrarem seus projetos para as versões mais recentes do RAD Studio, estejam eles utilizando Delphi ou C++ Builder. Em breve estaremos suportando mais uma plataforma de maneira 100% nativa, Linux 64 bit, e este movimento deve se intensificar.

Pensando nisso, estou iniciando uma série de artigos a respeito de migração, sendo este o primeiro deles. Vou tentar reunir aqui recursos que estão disponíveis e que podem auxiliar no processo de migração, e também compartilhar a experiência de alguns processos de atualização junto a alguns de nossos clientes.

Existem alguns temas recorrentes (e muito sensíveis) em um processo de migração. Abaixo estou listando os principais, sendo que a ordem não necessariamente atribui aos mesmos um grau de importância:

  • Suportar Unicode em todo o projeto
  • Migrar o framework de acesso a dados
  • Passar a compilar para 64 bit no Windows
  • Migrar ou remover componentes de terceiros
  • Migrar o middleware (quando em uso)

Temos também outros tópicos que não estão exatamente relacionadas a migração, mas sim a expansão da aplicação para outras plataformas, já que no Delphi/C++ temos o benefício de utilizar exatamente o mesmo código-fonte para múltiplas arquiteturas:

  • Migrar de uma plataforma de banco de dados para outra
  • Suportar múltiplas plataformas de banco de dados simultaneamente
  • Passar de uma aplicação originalmente Windows para múltiplas plataformas

Cada um destes macro tópicos será tratado em um ou mais artigos individualmente, e novos poderão ser adicionados de acordo com seu feedback!

Para dar o pontapé inicial, vamos falar de Unicode, um tema abstrato para a maioria da comunidade, o qual pode significar ao mesmo tempo uma enorme dor de cabeça em seu projeto, ou literalmente nada. Tudo vai depender do contexto de sua aplicação. Hoje vamos entender o que é Unicode e sua importância.

Sobre Unicode

The Unicode Blog

Unicode foi criado e segue sendo mantido pelo Unicode Consortium, uma entidade criada por desenvolvedores: http://www.unicode.org/

Em sua definição podemos encontrar a seguinte declaração (em tradução livre):

Unicode fornece um número exclusivo para cada carácter,
Não importa qual plataforma,
Não importa qual aplicação,
Não importa qual linguagem.

Existe também um blog oficial (http://blog.unicode.org/) onde você pode encontrar artigos interessantes sobre padrões e versões da especificação do Unicode, atualmente em sua versão 9.0 (http://www.unicode.org/versions/Unicode9.0.0/).

Definições e Objetivos

Unicode é um padrão para a definição e identificação de caracteres e símbolos em todas as línguas escritas, atribuindo um valor único a cada caractere ou símbolo. O Consórcio Unicode define qual número (ponto de código) representa qual caractere ou símbolo.

Em 1991, obtivemos o Unicode versão 1.0.0, que foi estendido para 1.0.1 e 1.1 de acordo com o padrão ISO-10646. Originalmente, o Unicode 1.1 estava limitado a 64K caracteres e símbolos, o que significava que 2 bytes eram suficientes para codificar todos os caracteres. Infelizmente, o 64K também era insuficiente para suportar todas as línguas escritas no mundo.

Como resultado, o Unicode 2.0, a partir de junho de 1996, estendeu o número de pontos de código para $ 10FFFD caracteres e símbolos (1.114.109 para ser exato). No momento da escrita, o Unicode 9.0 é atual, para o qual o Consórcio Unicode já definiu 128.172 caracteres no padrão.

Formatos de Transformação Unicode

Os dados Unicode (os valores de ponto de código) podem ser apresentados em diferentes formatos, como UTF-8, UTF-16 ou UTF-32. Também podemos opcionalmente comprimir dados Unicode. UTF significa Unicode Transformation Format, e cada UTF define o mapeamento entre um ponto de código para uma série única de bytes que representam esse ponto de código. Assim, onde o próprio Unicode define o caractere ou símbolo que pertence a um ponto de código, o UTF define a representação física (no arquivo no disco ou na memória, por exemplo).

UTF-8
Usando UTF-8, temos entre 1 e 4 bytes para cada caractere Unicode.

UTF-16
Usando UTF-16, obtemos 2 ou 4 bytes para cada caractere Unicode. Esta codificação é mais fácil e mais rápida de processar do que UTF-8.

UTF-32
Usando UTF-32 sempre obtemos exatamente 4 bytes para cada caractere Unicode. Esta é a codificação mais fácil de todas, mas também a que resulta no maior espaço de armazenamento.

API do Windows
Desde Windows NT e 2000, a API do Windows oferece suporte a dois conjuntos de APIs: um para ANSI (A) e um para caracteres Unicode (W), portanto, outra importante razão para você migrar sua aplicação para um compilador mais recente.

Unicode no Delphi/C++ Builder

Feitas as apresentações e formalidades, no próximo artigo iniciaremos por explorar os recursos e técnicas para migração de sua aplicação “Pré-Unicode”, seja tornando-a 100% aderente ao padrão Unicode, ou simplesmente garantindo que ela irá se comportar bem com os novos compiladores e sistemas operacionais, caso você não necessite realmente de suporte a múltiplos idiomas e caracteres estendidos.

Até breve!