A Alcinoe Component Library, criada por Zeus64, é uma biblioteca de componentes visuais e não visuais de código aberto para Delphi.
Reprodutor de vídeo OpenGL completo, wrapper Delphi para WebRTC, TEdit nativo para iOS/Android, controles FireMonkey aprimorados, Firebase cloud messaging, SDK de login do Facebook para Android/iOS, parser Json/Bson, wrapper ImageMagick, cliente MongoDB.
Alcinoe é compatível com Delphi Rio 10.3.3 e Delphi Sydney 10.4.2.
https://github.com/Zeus64/alcinoe
Com o Delphi Alexandria 11.1, suporte para download de MOD (removido):
Alcinoe agora é totalmente compatível com Delphi Athens 12.3..
Instale o Alcinoe.
Se você não planeja usar nenhum componente visual do Alcinoe em tempo de design, então você não precisa instalar nada, apenas adicione {alcinoe_rootdir}\source ao caminho de pesquisa do seu projeto.
Se você planeja usar componentes visuais em tempo de design, então você precisa instalar o BPL. Abra o Delphi e vá em componente > Instalar Pacotes... > e escolha o BPL localizado em {alcinoe_rootdir}\lib\bpl\alcinoe\Win32\sydney\Alcinoe_sydney.bpl (se você estiver usando o Delphi Sydney, caso contrário, escolha o diretório que corresponde à sua versão do Delphi). Você ainda precisa adicionar {alcinoe_rootdir}\source ao seu caminho de pesquisa.
O Alcinoe também melhora um pouco os códigos-fonte originais do Delphi. Desta forma, você precisa ir para {alcinoe_rootdir}\embarcadero\sydney\10_4_2 e executar update.bat para recuperar e corrigir o código-fonte original do Delphi. O arquivo batch assume que o código-fonte original está localizado em "c:\Program Files (x86)\Embarcadero\Studio\21.0\source" e que você tem o GIT no seu caminho. Após a cópia e correção do código-fonte do Delphi, você precisa incluir este código-fonte no caminho de pesquisa do seu projeto.
Para finalizar, muitas bibliotecas usam recursos do Java 1.8 (como webRTC, exoplayer, etc.). Desta forma, devemos fazer o "desugaring" (o "desugaring" permite que você use esses recursos em dispositivos mais antigos, substituindo novos bytecodes e APIs de linguagem por versões mais antigas durante o processo de compilação). Com o d8.bat (substituição do dx.bat), o "desugaring" é ativado por padrão. Assim, você pode usar a maioria das últimas alterações na linguagem, mesmo ao direcionar dispositivos mais antigos. Aguardando a substituição do DX.bat pelo D8.bat pela Embarcadero, devemos fazer do DX.bat um "proxy" para o D8.bat. Para isso, basta substituir o seu arquivo DX.bat original (o meu está localizado em c:\SDKs\android\build-tools\30.0.3\d8.bat) pelo arquivo localizado em {alcinoe_rootdir}\tools\D8Proxy\dx.bat. Mais detalhes aqui: https://quality.embarcadero.com/browse/RSP-24155
Player de vídeo OpenGL completo para FireMonkey.
O ALVideoPlayer renderizará um vídeo em uma TEXTURA. Isso é realmente importante porque você pode integrar totalmente o vídeo no formulário do Delphi e pode colocar qualquer controle por cima, pois suporta a ordem Z. Os players de vídeo oficiais do Delphi são apenas janelas de player de vídeo nativas na parte superior do formulário e, portanto, não suportam a ordem Z.
No Android, uso o ExoPlayer. O ExoPlayer suporta recursos como streaming adaptativo dinâmico via HTTP (DASH), HLS, SmoothStreaming e criptografia comum, que não são suportados pelo MediaPlayer. Ele foi projetado para ser fácil de personalizar e estender. No iOS, uso o AVPlayer, que também suporta HLS, como o ExoPlayer.
player de vídeo para FireMonkey player de vídeo para FireMonkey player de vídeo para FireMonkey
wrapper Delphi para WebRTC
WebRTC (Web Real-Time Communications) é uma tecnologia que permite que aplicativos e sites da web capturem e, opcionalmente, transmitam mídia de áudio e/ou vídeo, bem como troquem dados arbitrários entre navegadores e aplicativos móveis, sem a necessidade de um intermediário. O conjunto de padrões que compõem o WebRTC permite compartilhar dados e realizar videoconferências ponto a ponto, sem que o usuário precise instalar plug-ins ou qualquer outro software de terceiros.
O componente TALWebRTC facilita a adição de chat de vídeo e áudio aos seus aplicativos, o que abre um mundo totalmente novo de interatividade.
wrapper Delphi para WebRTC
controles nativos TEdit e TMemo para iOS/Android no Firemonkey
A ideia é combinar controles FireMonkey com controles nativos da plataforma quando a implementação de certas funcionalidades em um controle específico se torna muito difícil (como webbrowser, edit, memo, datepicker, etc.). No entanto, não se trata de criar várias formas distintas para várias plataformas, como a opção oferecida por http://www.turbococoa.com/ (embora essa opção também seja uma boa alternativa em alguns casos, a escolha é sua).
Em Delphi (berlin), já existe um controle de plataforma iOS que foi bem implementado, mas quase nenhum controle de plataforma Android, então comecei a criar controles nativos para Android/iOS, como TEdit/TMemo. Esses controles funcionam principalmente como janelas que são colocadas sobre o formulário (portanto, não há ordem Z com controles FireMonkey).
Desenho.
Desenho.
Controles FireMonkey com bufferização rápida/dupla e renderização nativa.
Retângulo.
Círculo.
Texto (Também pode renderizar texto HTML em iOS/Android/Windows/macOS).
Glifo.
etc.
TALRectangle
TALRectangle
O fato
A pintura dos controles FireMonkey pode ser, às vezes, lenta, ou, de forma diferente, não suficientemente rápida para uma rolagem fluida. Por exemplo, se você simplesmente observar um TRectangle básico com cantos arredondados, o procedimento de pintura pode levar cerca de 3ms! Portanto, se você tiver cerca de 20 TRectangles visíveis na tela, levará cerca de 60ms para repintar a tela inteira (e normalmente você não tem apenas TRectangle, você também tem TLabel, TCheckbox, etc.). Depois, é apenas matemática: leva 100ms para repintar a tela, então você só consegue cerca de 10 quadros por segundo (na realidade, você terá muito menos), então a rolagem não pode ser fluida 🙁
A solução
Eu não queria reconstruir os controles FireMonkey, é um trabalho muito grande para mim, e, em vez disso, tentei encontrar uma solução intermediária. Isso é o que encontrei adicionando a propriedade "double-buffered" aos controles FireMonkey. Em vez de repintar e repintar (e repintar) os controles para cada movimento de pixel da barra de rolagem, eu primeiro pinto o controle em um "buffer" que armazeno diretamente na memória da GPU (através de TTexture), e quando o sistema me pede para repintar os controles, em vez de chamar novamente o algoritmo de pintura, eu simplesmente redesenho o buffer TTexture.
Os resultados
Como eu disse antes, leva 3ms apenas para pintar um TRectangle simples com cantos arredondados. Com minha propriedade de double-buffering, agora leva cerca de 0,1ms! Então, agora a rolagem parece muito mais fluida!
OpenGL draw => Substituído por draw nativo do iOS/Android.
A maioria das formas básicas (como TRectangle, TCircle, etc.) usa OpenGL para desenhar, o que não é muito eficiente; por exemplo, para desenhar um círculo com OpenGL, na verdade você desenha 50 triângulos. Isso frequentemente resulta em baixa qualidade: https://quality.embarcadero.com/browse/RSP-15206. Para roundrect, é ainda pior, porque você deve primeiro calcular o caminho e depois desenhá-lo (muito mais lento que TCircle).
Outro problema é que todos esses desenhos dependem de Form.quality. Se você definir form.quality para highquality, tudo o que você fizer na tela será multiamostrado, como desenhar uma imagem, o que pode ser problemático porque a imagem será anti-aliased. Se você definir form.quality para highperformance, o desenho será muito grosseiro (sem anti-aliasing).
Para resolver isso, criei o buffer do meu controle usando as APIs NATIVAS DO ANDROID/IOS. Dessa forma, teremos um desenho de alta qualidade com alta velocidade, sem depender de form.quality.
TALCircle
Controles FireMonkey aprimorados.
ScrollBox
TabControl
RangeTrackBar
RangeTrackBar
player de vídeo para FireMonkey player de vídeo para FireMonkey player de vídeo para FireMonkey
Animação de Confete caindo
ALConfetti é uma biblioteca Delphi simples para criar uma animação de confete caindo, configurável e de alto desempenho.
confete
Firebase cloud messaging
Um método multiplataforma para usar o Firebase Cloud Messaging (FCM) para receber notificações push. Com o FCM, você pode notificar um aplicativo cliente de que novos e-mails ou outros dados estão disponíveis para sincronização. Você pode enviar mensagens de notificação para aumentar o engajamento e a retenção do usuário. Para casos de uso como mensagens instantâneas, uma mensagem pode transferir uma carga útil de até 4 KB para um aplicativo cliente.
Login via SDK do VKontakte/Facebook para Android/iOS.
O SDK do VKontakte/Facebook para Android permite que as pessoas façam login no seu aplicativo usando o login do VKontakte/Facebook. Ao fazer login no seu aplicativo com o VKontakte/Facebook, as pessoas podem conceder permissões ao seu aplicativo para que você possa recuperar informações ou realizar ações em nome delas no VKontakte/Facebook.
Filtros de editor de fotos para Android/iOS.
Com o TALColorAdjustEffect, filtros de fotos deslumbrantes com aprimoramento automático com um toque, tornando suas fotos bonitas e expressivas em apenas alguns minutos!
Player de vídeo para FireMonkey.
Analisador JSON.
TALJsonDocument é um analisador/escritor Delphi para o formato de dados JSON / BSON. Ele suporta analisadores DOM e SAX (observe que um nome melhor poderia ser SAJ para Simple API for JSON em vez de SAX para Simple API for XML, mas como o conceito de SAX é bem conhecido, mantenho este nome), suporta o formato BSON e usa uma sintaxe semelhante ao TALXMLDocument / TXMLDocument. TALJsonDocument também pode exportar dados Json / Bson em TALStringList.
Ao lidar com a análise de algum conteúdo (textual), geralmente são consideradas duas direções. No mundo JSON, geralmente você precisa escolher entre:
Um analisador DOM, que cria uma estrutura de árvore em memória de objetos que mapeia o conteúdo JSON;
Um analisador SAX, que lê o conteúdo JSON e, em seguida, chama eventos predefinidos para cada elemento do conteúdo JSON.
Na verdade, os analisadores DOM usam internamente um analisador SAX para ler o conteúdo JSON. Portanto, devido à sobrecarga da criação de objetos e à inicialização de suas propriedades, os analisadores DOM são normalmente três a cinco vezes mais lentos que os analisadores SAX (e usam muito mais memória para armazenar todos os nós). No entanto, os analisadores DOM são muito mais poderosos para lidar com os dados: assim que são mapeados em objetos nativos, o código pode acessar qualquer nó a qualquer momento, enquanto um acesso baseado em SAX terá que ler todo o conteúdo JSON novamente.
A maioria dos analisadores JSON disponíveis em Delphi usa uma abordagem semelhante ao DOM. Por exemplo, a unidade DBXJSON, incluída desde o Delphi 2010, ou a biblioteca SuperObject criam uma instância de classe que mapeia cada nó JSON. Para obter a melhor velocidade, TALJsonDocument implementa um analisador DOM e também um analisador SAX.
TALJsonDocument também pode suportar comentários dentro da fonte JSON, o que é uma extensão das especificações JSON.
A sintaxe de TALJsonDocument é muito semelhante à de TALXMLDocument / TXMLDocument.
TALJsonDocument está disponível em 2 variantes: TALJsonDocument, que é construído sobre ansiString (portanto, UTF-8), e TALJsonDocumentU, que é construído sobre uma string Unicode (portanto, UTF-16).
Exemplo:
{
_id: 1, // comentários
name: { first: “John”, last: “Backus” },
birth: new Date('1999-10-21T21:04:54.234Z'),
contribs: [ “Fortran”, “ALGOL”, “Backus-Naur Form”, “FP” ],
awards: [
{ award: “National Medal of Science”,
year: 1975,
by: “National Science Foundation” },
{ award: "Turing Award",
year: 1977,
by: "ACM" }
],
spouse: "",
address: {},
phones: []
}
Para acessar os nós do documento:
MyJsonDoc.loadFromJson(AJsonStr, False);
MyJsonDoc.ParseOptions := [poAllowComments]; // para permitir comentários dentro da fonte JSON.
MyJsonDoc.childnodes['_id'].int32;
MyJsonDoc.childnodes['name'].childnodes['first'].text;
MyJsonDoc.childnodes['name'].childnodes['last'].text;
MyJsonDoc.childnodes['birth'].datetime;
for i := 0 to MyJsonDoc.childnodes['contribs'].ChildNodes.count – 1 do
MyJsonDoc.childnodes['contribs'].childnodes[i].text;
for i := 0 to MyJsonDoc.childnodes['awards'].ChildNodes.count – 1 do begin
MyJsonDoc.childnodes['awards'].childnodes[i].childnodes['award'].text;
MyJsonDoc.childnodes['awards'].childnodes[i].childnodes['year'].text;
MyJsonDoc.childnodes['awards'].childnodes[i].childnodes['by'].text;
end;
Ou, se você não tem certeza da existência dos nós antes de acessá-los ou não quer verificar, você também pode fazer:
MyJsonDoc.GetChildNodeValueInt32('_id', 0{padrão se o nó não existir});
MyJsonDoc.GetChildNodeValueText(['name', 'first'], ""{padrão se o nó não existir});
MyJsonDoc.GetChildNodeValueDateTime('birth', Now{padrão se o nó não existir});
Para criar os nós do documento:
MyJsonDoc.addchild('_id').int32 := 1;
with MyJsonDoc.addchild('name', ntObject) do begin
addchild('first').text := 'John';
addchild('last').text := 'Backus';
end;
MyJsonDoc.addchild('birth').dateTime := Now;
with MyJsonDoc.addchild('contribs', ntArray) do begin
addchild.text := ‘Fortran’;
addchild.text := ‘ALGOL’;
addchild.text := ‘Backus-Naur Form’;
addchild.text := ‘FP’;
end;
with MyJsonDoc.addchild(‘awards’, ntArray) do begin
with addchild(ntObject) do begin
addchild(‘award’).text := ‘National Medal of Science’;
addchild('year').int32 := 1975;
addchild('by').text := 'National Science Foundation';
end;
with addchild(ntObject) do begin
addchild('award').text := 'Turing Award';
addchild('year').int32 := 1977;
addchild('by').text := 'ACM';
end;
end;
MyJsonDoc.addchild('spouse');
MyJsonDoc.addchild('address', ntObject);
MyJsonDoc.addchild('phones', ntArray);
Você também pode criar/atualizar nós desta forma:
MyJsonDoc.SetChildNodeValueInt32('_id', 0);
MyJsonDoc.SetChildNodeValueText(['name', 'first'], 'John');
MyJsonDoc.SetChildNodeValueDateTime('birth', Now);
Para carregar e salvar de BSON:
MyJsonDoc.LoadFromFile(aBSONFileName, False{saxMode}, True{BSON});
MyJsonDoc.SaveToFile(aBSONFileName, False{saxMode}, True{BSON});
Para analisar um documento JSON no modo SAX:
MyJsonDoc.onParseText := procedure (Sender: TObject;
const Path: AnsiString;
const name: AnsiString;
const Args: array of const;
NodeSubType: TALJSONNodeSubType)
begin
case NodeSubType of
nstFloat: Writeln(Path + ‘=’ + ALFloatToStr(Args[0].VExtended^, ALDefaultFormatSettings));
nstText: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString));
nstObjectID: Writeln(Path + ‘=’ + ‘ObjectId(“‘+ALBinToHex(ansiString(Args[0].VAnsiString))+'”)’);
nstBoolean: Writeln(Path + ‘=’ + ALBoolToStr(Args[0].VBoolean,’true’,’false’));
nstDateTime: Writeln(Path + ‘=’ + ALFormatDateTime(”’ISODate(“”yyyy”-”mm”-”dd”T”hh”:”nn”:”ss”.”zzz”Z”)”’, Args[0].VExtended^, ALDefaultFormatSettings));
nstNull: Writeln(Path + ‘=’ + ‘null’);
nstRegEx: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString));
nstBinary: Writeln(Path + ‘=’ + ‘BinData(‘+inttostr(Args[1].VInteger)+’, “‘+ansiString(ALBase64EncodeStringNoCRLF(ansiString(Args[0].VAnsiString)))+'”)’);
nstJavascript: Writeln(Path + ‘=’ + ansiString(Args[0].VAnsiString));
nstInt32: Writeln(Path + ‘=’ + ‘NumberInt(‘+inttostr(Args[0].VInteger)+’)’);
nstTimestamp: Writeln(Path + ‘=’ + ‘Timestamp(‘+inttostr(int64(cardinal(Args[0].VInteger)))+’, ‘+inttostr(int64(cardinal(Args[1].VInteger)))+’)’);
nstInt64: Writeln(Path + ‘=’ + ‘NumberLong(‘+inttostr(Args[0].VInt64^)+’)’);
end;
end;
MyJsonDoc.LoadFromJSON(AJsonStr, true{saxMode});
Wrapper do ImageMagick para Delphi.
Utilize o ImageMagick® para criar, editar, compor ou converter imagens bitmap. Ele pode ler e gravar imagens em uma variedade de formatos (mais de 200), incluindo PNG, JPEG, GIF, HEIC, TIFF, DPX, EXR, WebP, Postscript, PDF e SVG. Utilize o ImageMagick para redimensionar, inverter, espelhar, rotacionar, distorcer, inclinar e transformar imagens, ajustar as cores das imagens, aplicar vários efeitos especiais ou desenhar texto, linhas, polígonos, elipses e curvas de Bézier.
Exemplo:
var aWand: PMagickWand;
begin
//Cria a biblioteca ImageMagick.
alCreateImageMagickLibrary({alcinoe_rootdir} + ‘\lib\dll\imagemagick\win32\imagemagick’, min(2, System.CPUCount){aThreadLimit});
try
//cria o ponteiro wand
aWand := ALImageMagickLib.NewMagickWand;
try
//carrega a imagem
if ALImageMagickLib.MagickReadImage(aWand, pansiChar(aInputFilename)) <> MagickTrue then RaiseLastMagickWandError(aWand);
//Define a qualidade de compressão
se ALImageMagickLib.MagickSetImageCompressionQuality(aWand,80) <> MagickTrue então RaiseLastMagickWandError(aWand);
//ajusta automaticamente a imagem
se ALImageMagickLib.MagickAutoOrientImage(aWand) <> MagickTrue então RaiseLastMagickWandError(aWand);
//Redimensiona a imagem usando o filtro Lanczos
se ALImageMagickLib.MagickResizeImage(aWand, 640, 480, LanczosFilter) <> MagickTrue então RaiseLastMagickWandError(aWand);
//salva a imagem
ALImageMagickLib.MagickWriteImage(aWand, pansiChar(aOutputFilename));
finally
ALImageMagickLib.DestroyMagickWand(aWand);
end;
finally
alFreeImageMagickLibrary;
end;
end;
Cliente MongoDb
Cliente Delphi para o banco de dados MongoDB. Um driver Delphi (com pool de conexões) para acessar um servidor mongoDB. Um pool de conexões é um cache de conexões de banco de dados mantido para que as conexões possam ser reutilizadas quando forem necessárias futuras solicitações ao banco de dados. No pool de conexões, após a criação de uma conexão, ela é colocada no pool e reutilizada, para que não seja necessário estabelecer uma nova conexão. Se todas as conexões estiverem em uso, uma nova conexão é criada e adicionada ao pool. O pool de conexões também reduz o tempo que um usuário deve esperar para estabelecer uma conexão com o banco de dados.
Exemplo:
aJSONDoc := TALJSONDocument.create;
aMongoDBClient := TAlMongoDBClient.create;
try
aMongoDBClient.Connect("", 0);
aMongoDBClient.SelectData('test.exemple',
'{fieldA:123}', // a consulta
‘{fieldA:1, fieldB:1}’, // os campos de retorno
aJSONDoc.node);
aMongoDBClient.disconnect;
for i := 0 to aJSONDoc.node.childnodes.count – 1 do
with aJSONDoc.node.childnodes[i] do
writeln(aJSONDoc.node.childnodes[i].nodename + ‘=’ + aJSONDoc.node.childnodes[i].text)
finally
aMongoDBClient.free;
aJSONDoc.free;
end;
Exemplo com pool de conexões:
aMongoDBConnectionPoolClient := TAlMongoDBConnectionPoolClient.create(aDBHost, aDBPort);
try
::Thread1::
aMongoDBConnectionPoolClient.SelectData('test.example',
'{fieldA:123}', // a consulta
‘{fieldA:1, fieldB:1}’, // os campos de retorno
aLocalVarJSONDOC.node);
::Thread2::
aMongoDBConnectionPoolClient.SelectData('test.example',
'{fieldA:999}', // a consulta
‘{fieldA:1, fieldB:1}’, // os campos de retorno
aLocalVarJSONDOC.node);
finally
aMongoDBClient.free;
end;
Exemplo de monitoramento de cauda:
aMongoDBTailMonitoringThread := TAlMongoDBTailMonitoringThread.Create(
aDBHost,
aDBPort,
‘test.cappedCollectionExemple’
‘{}’, // a consulta
‘{fieldA:1, fieldB:1}’, // os campos de retorno
Procedure (Sender: TObject; JSONRowData: TALJSONNode)
begin
writeln('Novo item adicionado em cappedCollectionExemple: ' + JSONRowData.childnodes['fieldA'].text);
end,
procedure (Sender: TObject; Error: Exception)
begin
writeln(Error.message);
end);
….
aMongoDBTailMonitoringThread.free;
Cliente WebSocket
Cliente WebSocket para Delphi implementado sobre WinHTTP. O WebSocket é um protocolo de comunicação que permite abrir uma sessão de comunicação interativa bidirecional entre o navegador do usuário e um servidor. Com ele, você pode enviar mensagens para um servidor e receber respostas orientadas a eventos sem precisar consultar o servidor para obter uma resposta.
TStringList rápido
TALStringList funciona da mesma forma que o TStringList do Delphi, exceto que permite pesquisar um nome=valor usando um algoritmo de ordenação rápida quando a lista está ordenada. Além disso, o TALStringList usa um algoritmo independente de localidade (baseado no valor ordinal de 8 bits de cada caractere) em vez de AnsiCompareText e AnsiCompareStr usados pelo TStringList do Delphi. No final, a ordenação no TALStringList é até 10 vezes mais rápida do que no TStringList do Delphi. Além disso, o TALStringList não é um TStringList Unicode, mas sim uma lista de strings Ansi.
TALNVStringList (NV para NameValue) é o mesmo que TALStringList (também usa um algoritmo de ordenação rápida), exceto que aqui a otimização é voltada para listas de nome/valor em vez de listas de strings.
TALHashedStringList: TALHashedStringList é o mesmo que TALStringList, exceto que usa uma tabela hash interna em vez de um algoritmo de ordenação rápida. Ao usar TALHashedStringList em vez de TALStringList, você pode melhorar o desempenho quando a lista contém um grande número de strings (caso contrário, se sua lista não contiver muitas strings, o desempenho é menor que o do TALStringList devido ao custo de calcular o hash).
Executador PHP
ALPHPRunnerEngine é um componente simples, mas útil, para usar facilmente o PHP (qualquer versão) como linguagem de script em aplicativos Delphi. ALPHPRunnerEngine permite executar scripts PHP dentro do programa Delphi sem um servidor web. ALPHPRunnerEngine usa a interface CGI/FastCGI do PHP para se comunicar com o motor PHP.
Cliente Memcached.
Cliente Delphi para o banco de dados memcached.
O que é Memcached? Um sistema de cache de objetos na memória distribuído, de código aberto e de alto desempenho, genérico por natureza, mas projetado para acelerar aplicativos web dinâmicos, aliviando a carga do banco de dados.
Memcached é um armazenamento de chave-valor na memória para pequenos trechos de dados arbitrários (strings, objetos) provenientes de chamadas de banco de dados, chamadas de API ou renderização de páginas.
Memcached é simples, mas poderoso. Seu design simples promove implantação rápida, facilidade de desenvolvimento e resolve muitos problemas enfrentados por grandes caches de dados.
Componente GSM.
O componente TAlGSMComm implementa mensagens de texto SMS através da interface de texto definida na especificação técnica GSM 07.05, versão 5.1.0, datada de dezembro de 1996. Existem várias variações desta especificação, usadas em modelos Nokia, Siemens, Ericsson, etc. Testamos internamente o Nokia 6230, mas os modelos Nokia 7190, 8890, 6210 e 9110 também devem funcionar. Telefones de outros fabricantes também funcionarão, desde que implementem a interface de texto. Cerca de 1/4 dos telefones atuais podem ser conectados a um PC (por meio de IR ou cabo serial), cerca de 1/3 desses são apenas de modo de texto, 1/3 são apenas de modo PDU e os outros 1/3 suportam tanto o modo de texto quanto o modo PDU. Alguns telefones (como o Nokia 5190) suportam SMS, mas usam um protocolo proprietário, que o TALGSMComm não suporta.
Para testar seu telefone, conecte-o ao seu PC através do cabo serial ou dispositivo IR (consulte a documentação do seu telefone para obter detalhes sobre como conectar). Digite "AT" em uma janela de terminal para verificar se a conexão foi estabelecida (você deve receber "OK" do telefone), e então digite "AT+CMGF=?". A resposta deve conter um "1", indicando que ele suporta o modo de texto. Se ambos esses testes forem aprovados, então seu telefone atende aos requisitos básicos.
Cliente SQLite3
Consulta ao banco de dados SQLite3 e obtenha o resultado em formato XML ou em formato JSON/BSON.
E muito mais.
Executador CGI
Cliente HTTP (WinInet/WinHTTP)
Cliente MySQL
Cliente NNTP
Cliente POP3
Cliente SMTP
Analisador XML
WIN64
Infelizmente, no win64, perdemos toda a herança do FastCode (que era baseado principalmente em ASM). Isso significa que a maioria das funções será de 2 a 10 vezes mais lenta. Você pode tentar executar /demo/ALStringBenchMark/ no win64 e no Win32 para ver a diferença de velocidade.