Keeping track of your cryptocurrency across multiple exchanges can be a chore. I built this simple cryptocurrency profit and loss tracker for your bitcoin and altcoin holdings. Basically the tracker ties into the CoinMarketCap.com REST API for getting currency quotes and allows you to store your current holdings in an FDMemTable. Once you add all of the cryptocurrencies that you hold into the TStringGrid you can add the price that you paid for them and the amount that you have. The app does the needed calculations automatically using the quote data that it pulls down from CoinMarketCap when you press the Refresh button in the app.

I built the app interface mainly for Windows but it should also work well on OSX plus Android and IOS tablet devices. It does use a TMultiView to hold the list of 1300+ cryptocurrencies (double click to add) but some of the controls could be re-arranged for a better layout on phone size devices (by using a TTabControl). There are two TFDMemTables within the app. The first one is tied to the TRESTClient controls which I created using the REST Debugger. The REST Debugger basically has a cheat button which will create all of the needed controls to access a REST API and pull the data into a TFDMemTable with no code. In any event the TFDMemTable tied to the REST client holds the quote data that you request from the CoinMarketCap API. The other TFDMemTable holds the list of your cryptocurrency holdings. Both TFDMemTables are LiveBinded to their own TStringGrids. When you select one of your cryptocurrency holding records in the second TFDMemTable you can also edit the data in the edit fields on the right side of the app. They also use LiveBindings for updating the data in the holdings TFDMemTable. I also used the Vapor premium style to get the look and feel of the app.

I have published the full source code for the app over on GitHub. According to the Delphi IDE stats it took around 21 minutes to build this app. Be sure to check out the other blog post about integrating Delphi with the GDAX cryptocurrency trading API as well.

Head over and download the full source code for the Crypto Coin Profit Tracker for Delphi on GitHub.

Embarcadero Technologies has released a Community Edition of Delphi and C++Builder featuring the cross platform FireMonkey framework for Android, IOS, OSX, and Windows. FireMonkey can be used to develop cross platform apps with a single codebase and single UI in Object Pascal and C++. Cross platform apps save you time and money by allowing to you deploy development resources more efficiently. FireMonkey also leverages time saving low code technologies like FireDAC and LiveBindings. Users or companies with less than $5k in annual revenue and between 1 and 5 developers can use the Community Edition to developer apps for FREE. Once you reach the limit of $5k/year and 5+ developers the upgrade path is to the Professional edition of the product. The Community Edition has the exact same feature set as the Professional edition except for the license. There are also free trial versions of the Pro, Enterprise, and Architect version of the product available. There are over 600 tips and tricks for FireMonkey on FMXExpress.com to get you up to speed quickly on FireMonkey and get your cross platforms apps deployed to Android, IOS, OSX, and Windows FAST. Check out this quick tutorial for building your first app in Delphi Communty Edition:

Part 1: Introduction and Installation

Part 2: Building and Debugging in Delphi

Part 3: Architecture and Layers

Part 4: Designing User Interfaces

Part 5: Putting the Calculator Together

Also get the full source code for a comprehensive cross platform Field Service Template solution and a Hospitality Survey Template built in FireMonkey for Android, IOS, OSX, and Windows.

Head over and check out out of full announcement of the Delphi Community Edition!

The developer team over at KSDev has an add on called FMXLinux available for Delphi 10.2 Tokyo FireMonkey that allows you to compile your cross platform Delphi FireMonkey apps to Linux. Normally you can compile your FireMonkey apps to Windows, OSX, IOS, and Android but FMXLinux brings FireMonkey to the Linux platform. FMXLinux requires the Enterprise Edition of Delphi because it contains the Linux compiler. It is pretty amazing that a third party is able to add an entirely new platform to Delphi as an add on package which speaks to the power of the Object Pascal RTL architecture. FMXLinux allows your FireMonkey apps to run on the desktop in popular Linux distros like Ubuntu. It utilizes Gtk for it’s control framework on Linux.  Gtk also has a way to output Gtk apps to HTML5 and display them in the browser using Gtk Broadway. This basically means you can output FMXLinux apps to HTML5 and display them in the browser (which means FMXLinux actually brings you two platforms: Linux and HTML5). In addition to all of that FMXLinux allows you to use FireMonkey’s graphical capabilities on Linux in CGI scripts and KSDev provides an example. FMXLinux is a commercial tool so there is a cost involves to use it.

Head over and check out all of the different features of FMXLinux which brings you Delphi 10.2 FireMonkey on Linux and HTML5.

Google has some new requirements as of August 1st, 2018 for releasing apps on the Google Play Store. Developer Dave Nottage has released some workarounds for Delphi 10.2.3 Tokyo that address the Android 8 requirement. One of these requirements is that the app has a targetSdkVersion of 26 (note this is not the minSdkVersion just the target). If you are simply updating an existing app you have until Nov 1st, 2018 to make this upgrade. One of the main changes that targeting SDK version 26 brings with it is that permissions dialogs pop up at the time that the permission is needed and not when you install the app. Both Apple and Google made this change at some point so that permissions are more nuanced and granular. If you’re going to play in the mobile sand box you have to keep up with the constant changes and requirements that the mobile platforms require. In any event there are a number of tweaks you need to make to your Delphi apps that target Android in order to make them compatible with Android SDK 26. Dave Nottage has a blog post where he outlines what those changes are and has some code that helps handle the permission dialog box requirements. Part of the workaround includes disabling the android-support-v4.dex.jar include from your app and adding two additional JAR files that target SDK 26 (so don’t forget to do this). Another part of the solution is that you need to deploy some extra XML files in your app. Lastly the Android manifest file has to be updated with the new  targetSdkVersion.

Additionally, Embarcadero has a blog post about the issue and how it may be addressed in Delphi 10.3.

Head over and check out the full solution for targeting Android 8 (SDK 26) with Delphi 10.2.3 Tokyo.

The Alcinoe Component Library For Delphi provides an OpenGL texture based video play for both Android and IOS. If you are looking to have video playback in your Delphi FireMonkey apps on mobile devices this is a good solution to take a look at. On Android devices it utilizes the ExoPlayer and on IOS devices it utilizes the AVPlayer. “ExoPlayer is an open source project that is not part of the Android framework and is distributed separately from the Android SDK.” The audio side of ExoPlayer uses the Android MediaCodec API and so it requires at least Android 4.1. The video itself gets drawn to an OpenGL texture inside which means that the z-order is correct allowing you to place FireMonkey controls on top of your rendered video. Additionally, it looks like you can apply FireMonkey render effects like magnify and pencil to the rendering video which is a nice touch. The Alcinoe library is free over on GitHub with full source code. The library is quire extensive with other functionality as well. The library only provides a FireMonkey solution for Android and IOS devices and source code is available if you need to extend it to Windows, Linux, or OSX devices.

Head over and download the full source code for the Alcinoe library with OpenGL video playback for Delphi 10 FireMonkey.

The team over at KSDev (who also publish FMXLinux) have a massive set of custom styles for FireMonkey available over on their DelphiStyles.com site. There are over 39 different styles fore FireMonkey. Some of the styles are for all of FireMonkey’s platforms which include Android, IOS, macOS, Windows, and Linux while other styles look like they are for specific platforms (Windows, macOS, and Linux). In addition to all of the styles they have available they also have a FireMonkey UI Plus pack. The FM UI Plus pack contains a significant number of enhancements for FireMonkey which make your app more polished on Windows or macOS. Here is the current full list of enhancements:

• New default HQ style for macOS from delphistyles.com, which includes graphics with all specifics of “Sierra” and “High Sierra” at this moment
• New focused frame around controls on macOS, which looks as native
• New toolbar style, which can be merged with window caption to get more native look and feel on macOS
• Fixes of text drawing on macOS and Windows systems
• Fixes of TCalendar, TGrid drawing on Windows and macOS
• More all possible fixes and improvements for different platforms in the future
• Quickly implementation of UI changes for different platforms in the future
• Easy to Enable / Disable “FM UI Plus” for your application (just call project popup menu and select one item)

Utilizing custom styles and or deploying these FireMonkey enhancements can really polish the look and feel of your apps to deliver a profession product to your customers. The DelphiStyles are a commercial product which have a lifetime subscription (which I assume means you receive free updates for life). You can also bundle it for cheaper with FMXLinux and some of their other offerings. C++Builder utilizes FireMonkey styles as well so they are also usable in your C++ apps.

Head over and check out all of the professional looking unique styles for Delphi 10.2 FireMonkey on Android, IOS, macOS, and Windows.

The latest versions of Android are Android 8.1 and Android P (which is in preview and is assumed to be Android 9). One of FireMonkey’s target platforms is Android and it makes things much easier to access all of the goodies that Android has to offer with proper Object Pascal interface files. The API version of Android 8.1 is 27 and the API version of Android P is 28. As previously published I have provided Object Pascal interface files for the entire Android SDK from API version 10 to API version 26 over on Github. I used Java2Pas and Java2PasMerge to generate new Android interface files for Android 27 and Android 28. Java supports circular references while Object Pascal does not so Java2PasMerge combines the circular references into single files. The Android 28 interface files give you access from Object Pascal to things like android.net.wifi.rtt.WifiRttManager, android.view.DisplayCutout, android.graphics.drawable.AnimatedImageDrawable, and android.text.PrecomputedText. Keep in mind that at this time in mid 2018 the number of users with Android API level 27 is only 2% and Android API level 26 is 10.1%. If you want to take advantage of these new APIs most end users don’t have access to them on their own devices yet. However, if you are building enterprise level apps with FireMonkey and you control the devices that your users will have you can easily take advantage of these new features with these Object Pascal interface files. If you are targeting Android 8 with Delphi be sure to check out this other post as well.

Head over and check out all of the Object Pascal interface files for Delphi FireMonkey on Android.

It is surprisingly easy to launch your FireMonkey app on IOS from another app and pass it some basic settings. I have tested this solution on a recent IPad and IOS 11.4. This functionality is provided by Apple and you can easily modify your Delphi FireMonkey app to register it’s own URL Scheme and handle the incoming settings. The first thing you need to do is edit your info.plist.TemplateiOS.xml file in your project directory. Under the <%ExtraInfoPListKeys%> line you should add the following:

<key>CFBundleURLTypes</key>
<array>
<dict>
<key>CFBundleURLSchemes</key>
<array>
<string>myappurlschemename</string>
</array>
</dict>

Be sure to replace the myappurlschemename with the actual name of your app or at least the name of the scheme you want to register and use to launch your app. It gets used to launch the app in a URL like this: myappurlschemename://mypage?myname=myvalue You can paste myappurlschemename://mypage?myname=myvalue into Safari to test launching your app. There is also a good tutorial here for XCode so you can see how it works from the XCode side.

Next up you need to add some code to your app to handle the TApplicationEvent.OpenURL event. You can do this with the following code. You will want to add FMX.Platform to your uses section and you will want to start listening to the FMXApplicationEventService in your TMainForm.OnCreate event:

uses
FMX.Platform,
{$IFDEF IOS}
FMX.Platform.iOS
{$ENDIF}

procedure TMainForm.FormCreate(Sender: TObject);
var
  FMXApplicationEventService: IFMXApplicationEventService;
begin
  if TPlatformServices.Current.SupportsPlatformService
    (IFMXApplicationEventService, IInterface(FMXApplicationEventService)) then
    FMXApplicationEventService.SetApplicationEventHandler(HandleAppEvent);
end;

function TMainForm.HandleAppEvent(AAppEvent: TApplicationEvent;
  AContext: TObject): Boolean;
begin
  case AAppEvent of
     TApplicationEvent.OpenURL:
     begin
  {$IFDEF IOS}
       LaunchURL := TiOSOpenApplicationContext(AContext).URL;
  {$ENDIF}
     end;
  end;
  Result := True;
end;

When the event executes and your app is launched the LaunchURL string will get filled with the URL that the app was launched using. You can then parse the LaunchURL string to get the various parameters out of it. You’ll need IdURI and IdGlobal in your uses section for the below code. Here is the sample code to parse the URL:

var
Params: TStringList;
MyValue: String;
begin
  if LaunchURL<>'' then
    begin
      Params := TStringList.Create;
      try
        URI := TIdURI.Create(LaunchURL);
        try
          Params.Delimiter := '&';
          Params.StrictDelimiter := true;
          // Path = URI.Path
          Params.DelimitedText := URI.Params;
        finally
          URI.Free;
        end;

        for I := 0 to Params.Count -1 do
          begin
            Params.ValueFromIndex[I] := StringReplace(Params.ValueFromIndex[I], '+', ' ', [rfReplaceAll]);
            Params.ValueFromIndex[I] := TIdURI.URLDecode(Params.ValueFromIndex[I], IndyTextEncoding_UTF8());
          end;

	MyValue := Params.Values['myname'];
      finally
        Params.Free;
      end;
      LaunchURL := '';
    end;
end;

Check out the Delphi 10.2 Tokyo documentation for TApplicationEvent.OpenURL which shows you the other properties of TiOSOpenApplicationContext.

Developer TetrisSQC over on Github has released a ZX Spectrum Emulator built with Delphi Firemonkey. Apparently it works on Android, IOS, OSX, and Windows using a single codebase and single UI. The ZX Spectrum was an 8-bit computer that came out in 1982. There are also different variations in the hardware which were released later and the emulator supports some of those as well (48k, 128k, 2A/3A, Pentagon, and Scorpion). Reviewing the source code it looks like it uses the cross platform SDL library for handling sound. If you want to see how to utilize a cross platform library like this from Firemonkey on Android, IOS, OSX, and Windows this is a great example. Lots of good code here for scanline style drawing too. There is also all kinds of other great code Check out the conditional compilation for loading the library on each platform:

{$IFDEF MACOS}
{$IFDEF CPUARM}
  libsdl = 'libSDL2.a';
{$ELSE}
{$IFDEF IOS}
  libsdl = 'libSDL2.dylib';
{$ELSE}
  libsdl = 'libSDL.dylib';
{$ENDIF}
{$ENDIF}
{$ENDIF}
{$IFDEF MSWINDOWS}
  libsdl = 'SDL.dll';
{$ENDIF}
{$IFDEF ANDROID}
  libsdl = 'libSDL2.so';
{$ENDIF}

In any event full source code for the emulator is available over on Github. There are all kinds of games and various other apps that are available for the ZX Spectrum.

Head over and get the full source code for the ZX Spectrum emulator built in Delphi Firemonkey on Github.

Auto Tables for RAD Server is a powerful automation solution that allows you to automatically generate a REST API in Delphi 10.2 Tokyo. It will take a look at your existing database tables and automatically create the CRUD code for adding, editing, and deleting records from the existing database via a REST API. You can literally deploy a REST client and server solution for an existing FireDAC supported database in a few clicks. The REST API is deployed as a RAD Server. Auto Tables for RAD Server is similar to other solutions like DreamFactory, Sandman, and LoopBack. Once the server is generated it also generates a FireMonkey client for accessing the REST API. The Delphi FireMonkey client should run on Android, IOS, Windows, OSX, and Linux (with FMXLinux). There are actually three separate ways generated to access the REST API that you create. The first is a Delphi project with a DataModule suitable for building a FireMonkey client and leveraging LiveBindings to quickly build out the UI of your client. The second way is through a code only Object Pascal SDK that is generated for your REST API. Lastly, an OpenAPI spec file is generated that defines the endpoints in your API. You can use the OpenAPI spec file to generate all kinds of other clients for the REST API using either SwaggerHub or OpenAPI CodeGen. The Auto Tables for RAD Server project is free and open source using an MIT license. The project has extensive documentation and the REST API is packed with features like paging, custom queries, and aggregate queries for building dashboards. Additionally, it supports setting up enterprise grade permissions through RAD Server. You can probably also use the generated SDK in your C++Builder clients. At the time of this writing a RAD Server license is included with Delphi Enterprise Edition and up.

Head over and download the full source code for AutoTablesForRADServer and generate your REST API in seconds.

Auto Tables for RAD Server is a client server solution which auto generates a REST API client/server/OpenAPI for your databases. The sample application and database that comes Auto Tables for RAD Server is called Logger and uses InterBase. You can swap out InterBase for any other database supported by FireDAC. I went ahead and generated the Logger sample project in the Auto Tables Editor and it is provided with this post. The client project should run on Android, IOS, OSX, Windows, and Linux (through FMXLinux). The server should run on Windows and Linux but has only been tested on Windows. I hooked up the LiveBindings in the client to some TStringGrids and some buttons to execute the REST API calls. There are three REST endpoints which are correspond to GET POST and DELETE. GetLogger for requesting the list of records from the Logger database table. PostLogger for posting a new record into the Logger database table. And finally DeleteLogger for deleting a recording out of the Logger database table. All of the REST API are made to the included RAD Server project. As you will see in the RAD Server project the endpoints are contained within a TFDMemTable. The Auto Tables Editor also generates a FireDAC JSON file which can be loaded into the TFDMemTable inside the sample RAD Server project. This allows you to make changes to the REST API endpoints without having to entirely re-generate the server project. As you will see in the sample the documentation for the REST API is provided via Swagger-UI in the Docs directory of the sample. Here is the entire source code that I added to the sample project after the auto generation of the client and server were complete.

//
//
//
procedure TMainForm.GetStringGridSelChanged(Sender: TObject);
begin
  DeleteIdEdit.Text := GetStringGrid.Cells[0,GetStringGrid.Selected];
end;

procedure TMainForm.GetBTNClick(Sender: TObject);
begin
  AutoTablesClientDM.getloggerExecute;
end;

procedure TMainForm.PostBTNClick(Sender: TObject);
begin
  AutoTablesClientDM.postloggerExecute;
  GetBTNClick(Self);
end;

procedure TMainForm.DeleteBTNClick(Sender: TObject);
begin
  if DeleteIdEdit.Text<>'' then
   begin
     AutoTablesClientDM.deleteloggerExecute(DeleteIdEdit.Text);
     DeleteMemo.Lines.Append('Delete ' + DeleteIdEdit.Text + ' sent successfully!');
     DeleteIdEdit.Text := '';
     GetBTNClick(Self);
   end;
end;

Download the full source for the Auto Tables For RAD Server Sample Logger solution.

Browse and download the full source code for the Auto Tables For RAD Server Sample Logger solution on GitHub.

If you are new to working with a full featured framework like Firemonkey you may be wondering at the size of the apps that Delphi 10.3 Rio Firemonkey generates. The Firemonkey Framework has hundreds of thousands of lines of code that allows you to jump ahead and start building the app you want to build now instead of the bricks in the road to get there. Hopefully this infographic will provide some insight into what makes up an APK/IPA cross platform application deployed from Delphi 10.3 with the FMX framework. The infographic covers Android, IOS, Windows, and Mac OSX apps/packages/libraries/archives created using the Firemonkey framework. Tools that utilize the Firemonkey framework are Delphi 10.3, C++Builder 10.3, and RAD Studio 10.3. The infographic only covers Release mode (something you could deploy to your customers). I have also included a VCL section in the infographic so that you can compare the Windows only VCL framework to the cross platform FMX framework. Also keep in mind that when you use debug information or are in Debug mode your file could be significantly larger. The sizes of the generated files are included in the green circles. There is the normal compiled size and then there is the compressed or packaged size. APK and IPA files are packaged and compressed. The compressed sizes for Windows and Mac OSX were achieved using the 7Zip format. Here is some information directly from the infographic as well about what units are included in a FMX app on Android (it is slightly different on each platform) and how those units effect the size of the deployable file.

Let’s start off with a Hello World app which is basically a FMX form with a TLabel on the form. This comes out to around ~5.88MB when deployed to Android as an APK. Even though this is a Hello World app there is already much more functionality here than just the ability to print out ‘Hello World’ to the screen. A true ‘Hello World’ would be much smaller because it would lack these Firemonkey framework units. The FMX and RTL units included are:

System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants, FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Controls.Presentation, FMX.StdCtrls

Next up I’ve listed what I call a Basic App that clocks in at ~6.45MB. A basic app has some more visual controls available to it like a TListView, a TEdit, a TListBox, a TTabControl, a TMemo, and even some access to advertising. Here are the FMX units included (in addition to the units from the Hello World app):

FMX.ListView.Types, FMX.Memo, FMX.ListView.Appearances, FMX.ListView.Adapters.Base, FMX.Advertising, FMX.TabControl, FMX.ListBox, FMX.Layouts, FMX.Edit, FMX.ListView, FMX.ScrollBox

This next tier of app size I’ve termed Services because it is basically some Android JAR files which when fully included bring the app up to around ~6.61MB. These services are basically helper services for Android (some of which are provided by Google) like Google IAP, GCM, and Analytics. You can include and exclude each of these files from your APK separately. Here is a list of the additional files:

android-support-v4.dex.jar, cloud-messaging.dex.jar, fmx.dex.jar, google-analytics-v2.dex.jar, google-play-billing.dex.jar, google-play-licensing.dex.jar, google-play-services-*.dex.jar (there are a number of play services covered by this wildcard)

Next up we have what I have termed the Consumer App style app tier which rings in at around ~9.50MB. Obviously if you add more or differently functionality the size of your app can fluctuate greatly. You could also build games and they might fall in this size range depending on how many external graphics and sound you used. This type of app includes more functionality like the RESTClient, the in app purchases unit, sensors, a grid component, and the camera component. Here are the additional FMX and RTL units included by the IDE when these new components (in addition to all of the above) were added:

System.Sensors, System.Rtti, FMX.Grid, System.Sensors.Components, FMX.Media, REST.Response.Adapter, REST.Client, Data.Bind.Components, Data.Bind.ObjectScope, System.Actions, FMX.ActnList, FMX.InAppPurchase

Lastly we have the Enterprise and Database App tier which comes in at around ~11.1MB+ but can increase size from here the more you add to your app. This includes FireDAC functionality for accessing an SQLite database, LiveBindings to bind the data to a grid, accessing various path utility functions, and creating ini files for settings storage. At this level you can add tens of thousands of lines of code and lots of forms and the app could still be around this size. The RTL and FMX units included when this functionality was added (in addition to all of the above units) are as follows:

FireDAC.Stan.Intf, FireDAC.Stan.Option, FireDAC.Stan.Param, FireDAC.Stan.Error, FireDAC.DatS, FireDAC.Phys.Intf, FireDAC.DApt.Intf, Data.DB, FireDAC.Stan.ExprFuncs, FireDAC.Phys.SQLiteDef, System.Bindings.Outputs, Fmx.Bind.Editors, Data.Bind.EngExt, Fmx.Bind.DBEngExt, Data.Bind.Components, Data.Bind.DBScope, FireDAC.Phys,FireDAC.Phys.SQLite, FireDAC.Comp.Client, Fmx.Bind.Grid,FireDAC.Phys.SQLiteVDataSet, FireDAC.Comp.DataSet, System.IniFiles, System.IOUtils, FMX.Grid.Style, Data.Bind.Grid, REST.Types, Data.Bind.ObjectScope

You can also take a deep dive into the Firemonkey Framework itself using the Delphi Unit Dependency Scanner. The unit dependency scanner will show you all of the units that your app uses and all of the units that those units use in a treeview. It will also show line numbers of each unit and a total line number count of your entire project.

You can find out more about the Firemonkey Framework on the Embarcadero DocWiki and on the FiremonkeyX website.

Download the full Anatomy of a Firemonkey Framework Multi Platform App infographic for future reference.

OpenEMR is a “leading open-source electronic medical record and practice management software.” Auto Tables for RAD Server was used to generate a FireMonkey CRUD REST client and RAD Server REST API for the OpenEMR database schema. Auto Tables for RAD Server is an open source project that will take any FireDAC supported database and automatically generate a RAD Server REST API for the database. Additionally, Auto Tables for RAD Server will now automatically generate a CRUD REST client in Delphi FireMonkey to connect the RAD Server REST API. The automatically generated OpenEMR FireMonkey client should run on Android, IOS, macOS, Windows, and Linux (using FMXLinux). This is a single source client and a single UI. It uses a number of Delphi features like Tasks, the Embarcadero dark style (Material Oxford Blue), the EMS components, LiveBindings and much more. Both Auto Tables for RAD Server and the OpenEMR CRUD REST API sample are free and open source. You will need to edit the FDConnection component in the RAD Server project to enter your MySQL username, password, and hostname. Additionally, your database should be named openemr. Otherwise you will need to re-generate the project with Auto Tables for RAD Server using your specific database name. You can find out more about the OpenEMR project and download the source code over on GitHub. OpenEMR is built in PHP and uses MySQL as the database.

Head over and download the full source code for the OpenEMR CRUD REST API client and server for Delphi FireMonkey.

RAD Server has built in support for the OpenAPI (Swagger) REST endpoint documentation format. It provides both YAML and JSON definitions of the endpoints. RAD Server is the REST server framework that ships with RAD Studio (Delphi and C++Builder). A single site and multisite license come with RAD Studio Enterprise and Architect respectively. The open source Swagger Code Gen project can take your Swagger definition file and generate clients for your REST endpoints in a wide variety of languages and frameworks which should work on most platforms. This allows you to access RAD Server from pretty much any language or framework. Want to connect your Flutter client to RAD Server? Have at it using the dart client. Want to connect your fancy Python AI project to RAD Server? Have at it using the python client. What to connect your legacy Android app to RAD Server? There is an Android client for that. Want to connect from PHP (the language that runs 80% of the web) to RAD Server? There is a PHP client for that. There is an online Swagger Editor where you can upload your definition file and generate the clients. I took the default RAD Server Swagger JSON file (available from /api/apidoc.json) which is only the built in endpoints for RAD Server and plugged it into the online Swagger Editor. Once you add your own custom resource modules to RAD Server with your own endpoints it would contain your endpoints as well. You can find out more about documenting your RAD Server endpoints in the documentation. I generated a RAD Server REST client for each of their client options and uploaded that client to Github. The host was set to the default localhost:8080 search (which is what RAD Server’s debug server runs on by default).

In addition to REST Clients is also generates HTML documentation and Atlassian Confluence markup. The Confluence markup is in the cwiki project and the different HTML documentations are in dynamic-html, html, and html2 projects. The html2 project is probably the nicest of the three as it also contains sample usage code with each endpoint that corresponds to the other Swagger clients (curl, Java, Android, Obj-C, Javascript, C#, PHP, Perl, and Python). The online Swagger Editor itself uses the live documentation Swagger UI project which you can also download and use with your Swagger YAML/JSON files.

What was somewhat disappointing about the Swagger CodeGen clients so far is that of the three clients that I tried (bash, csharp, and powershell) all of them require extra work to get running. They have various syntax errors out of the box that have to be fixed before they will compile. This was not unique to the RAD Server JSON definition either as I tried the Swagger CodeGen with other Swagger JSON files with similar results. Additionally, I’m not so sure how clean this generated code is as it seems to have a lot of boilerplate code for what are relatively simple endpoints. The cross platform FireMonkey client code (for Android, IOS, OSX, Windows, and Linux) generated by Auto Tables for RAD Server feels much easier to read and simpler to use. At the same time starting out with a pre-generated client in the programming language or framework you need really goes a long way towards making RAD Server accessible and eases the integration process.

Here is a list of the REST clients/projects I generated for RAD Server:

• ada
• akka-scala
• android
• apex
• bash
• clojure
• cpprest (generator errored out)
• csharp
• csharp-dotnet2
• cwiki
• dart
• dart-jaguar
• dynamic-html
• eiffel
• elixir
• elm
• erlang-client
• flash
• go
• groovy
• haskell-http-client
• html
• html2
• java
• javascript (generator errored out)
• javascript-closure-angular
• jaxrs-cxf-client
• jmeter
• kotlin
• lua
• objc
• perl
• php
• powershell
• python
• qt5cpp
• r
• ruby
• rust
• scala
• scala-gatling
• scalaz
• swift
• swift3
• swift4
• tizen
• typescript-angular
• typescript-angularjs
• typescript-aurelia
• typescript-fetch
• typescript-inversify
• typescript-jquery
• typescript-node

Head over and check out all 50+ clients in many languages for RAD Server over on GitHub.

Delphi 10.3 Rio FireMonkey apps are cross platform with a single codebase and single UI that target the Android, IOS, Macos, Windows, and Linux platforms (FMXLinux was recently added to Delphi 10.3 Rio Enterprise and Architect). You can also deploy Delphi FireMonkey apps to the web using websockets and HTML5. The method for doing this is basically the FireMonkey app runs on a Windows or Linux server and it’s canvas draws are sent to the web browser via a websocket. Each user connection runs one copy of the app on the server (so one user one app). The server is running the app so it needs enough hardware for however many concurrent apps you want to run.

For FireMonkey Windows apps this can be achieved through Thinfinity VirtualUI. Thinfinity is a commercial product which a cost per concurrent user. The user connects to the Thinfinity server, Thinfinity launches the FireMonkey app, handles the user input, and sends the drawing to the browser client. Thinfinity has been around for quite a few years and I would consider it a pretty mature product. It supports enterprise features like load balancing and ActiveDirectory login. You can also use it with Windows apps written in other languages (like C++ and C#).

For FireMonkey Linux apps this can be achieved through FMXLinux and Gtk Broadwayd. FMXLinux is also a commercial product but has recently been made available to Delphi 10.3 Rio Enterprise and Architect developers for free (just open GetIt and install it). FMXLinux allows FireMonkey apps to run on Linux desktops using the Gtk UI library. Gtk comes with an application called Broadwayd which will stream the Gtk app out to HTML5 via websockets. Broadwayd runs on a single port (8080) per app and you can click compile in Delphi 10.3 Rio and see your FireMonkey app in the browser served up from you Linux machine if you start the broadwayd server prior to deployment. If you want to run a pool of FireMonkey apps on Linux like Thinfinity does on Windows you can set up a Linux bash script to do so.

The purpose of the bash script is to run X number of FireMonkey apps through broadwayd (remember 1 app per port) and then use a load balancer make all of the apps accessible via a single port. In order to do this second part there is a Linux package called balance which can do this for you. One limitation of it is that it will only do 16-32 apps in it’s app pool unless you compile the source yourself. You can install balance with “sudo apt install balance” on Ubuntu or “yum install balance” on CentOS. Broadwayd and balance are open source and free applications but the solution is also not as polished as Thinfinity UI. You could also build something in Delphi using TidMappedPortTCP instead of using balance. For commercial deployments I’d recommend going with Thinfinity though.

Here is the sample bash script I put together which handles hosting multiple apps on a single port for you. Save the script as gtkcloud.sh and “chmod +x gtkcloud.sh”. It takes two parameters. The first parameter is the path to the app you want to run and the second parameter is the port you want to run the load balanced app on.

#!/bin/bash
for i in {1..16}
do
    nohup broadwayd :$i &
    export GDK_BACKEND=broadway
    export BROADWAY_DISPLAY=:$i
    $1 &
    #echo ""
done

servers=""

for ii in {1..16}
do
    let port=8080+$ii
    servers="$servers localhost:$port:1 %"
done

echo $servers

balance $2 $servers

Example usage is as follows and would host 16 instances of /root/FireMonkeyPaintDemo on port 81.

./gtkcloud.sh /root/FireMonkeyPaintDemo 81

And that is all there is to it. You can run your Delphi FireMonkey apps on Android, IOS, Macos, Windows, Linux, AND the web using a single codebase and single UI.

Download the gtkcloud broadwayd + balance bash script for hosting Delphi FireMonkey FMXLinux apps.

Don’t have Delphi 10.3 Rio Enterprise or Architect? You can still use FMXLinux with you Delphi Pro FireMonkey apps.

Head over and check out the full website for FMXLinux and learn about deploying Delphi desktop apps to Linux.

There are a number of ways to deploy Delphi and C++Builder FireMonkey apps to Android devices which includes sideloading the apps (copying them to the device), through an enterprise MDM like AirWatch or MaaS260 (mobile device manager), and through Google Play. In addition to Android, FireMonkey apps run on Windows, MacOS, IOS, Linux, and HTML5. Google Play has a restriction that will be in effect on August 1st 2019 which will restrict adding new app (or updating existing apps) which target Android 28+ and contain native libraries as the main app unless they include Android 64-bit binaries in addition to Android 32-bit binaries. You can read a blog post from Google about these changes where they outline exactly what the requirements are and what the exceptions are. RAD Studio 10.3.x Rio (and previous versions) which consists of Delphi 10.3.x Rio and C++Builder 10.3.x Rio currently creates 32-bit binaries for Android.

According to the blog post three third party native files have an exception which allows them to continue to support 32-bit apps which target Android 28+ to Google Play. These three third party developer tools are:

• Corona Labs SDK – until August 2020
• Adobe Air software and the AIR SDK – until August 2020
• Unity 5.6.7 or older – until August 2021

For Delphi 10.3.x and C++Builder 10.3.x and earlier apps the important line in the blog post is this “The requirement does not apply to: APKs or app bundles that are not distributed to devices running Android 9 Pie or later.” What this means is that for Delphi 10.3.x and C++Builder 10.3.x apps (and all previous FireMonkey versions) you will need to add android:maxSdkVersion=”27″ to your AndroidManifest.template.xml file in the uses-sdk section. For example:

<uses-sdk android:minSdkVersion="%minSdkVersion%" 
android:targetSdkVersion="%targetSdkVersion%" 
android:maxSdkVersion="27" />

What this line does is restrict your app from running on Android 9 Pie (Android 28+) devices which at the time of this writing is only ~10% of Android devices. I tested this solution and Google Play does not display a warning when you upload your Android 32bit app with the maxSdkVersion set. You can still continue to add new FireMonkey apps and update existing apps through Google Play with the maxSdkVersion set. Additionally, you can continue to sideload and deploy your current FireMonkey apps via MDM solutions to Android devices. According to the blog post “Google Play will continue to deliver apps to 32-bit devices. This requirement means that apps with 32-bit native code will need to have an additional 64-bit version as well.” [to be able to target devices running Android 28+]

Developers and third party developer tools like RAD Studio Delphi and C++Builder, Unity, and Adobe AIR are at the mercy of requirements handed down by Apple and Google in order be listed on the major app stores. These requirements constantly change and require updates which is why building apps for Android and Google is a commitment to updating your app frequently and staying up to date with the latest developer tools. Within the Delphi ecosystem this means being on the Update Subscription. Companies that make developer tools for Android and IOS are also committing for a price to keeping their tooling up to date in partnership with their customers.

A more experimental view of Android 64-bit app requirement is that all that Google Play seems to currently check for is that a library (or just a file) exists at lib/arm64-v8a/libMyapp.so in addition to the 32-bit version of your app located at lib/armeabi-v7a/libMyapp.so. I uploaded an Android APK to Google Play with a 32-bit FireMonkey library generated with Delphi 10.3.x Rio in both the armeabi-v7a and arm64-v8a directories and Google Play displayed no warning about missing Android 64-bit support. According to this StackOverflow answer “64-bit Android can use 32-bit native libraries as a fallback, only if System.loadlLibrary() can’t find anything better in the default search path.”. What this means is that it may be possible create a 64-bit Android binary shim in the arm64-v8a directory using a different tool (the Android NDK?) that loads your FireMonkey 32-bit binary from the armeabi-v7a directory if you need to target Android 9 Pie (Android 28+) devices with RAD Studio 10.3.x apps through Google Play.

Embarcadero has a blog post titled “May 2019 RAD Studio Roadmap Commentary from Product Management” where they outline their plan for Android 64-bit support for Android 9 Pie (Android 28+) devices. It states:

“As of August 2019, Google will require that all Google Play Store applications are 64-bit enabled. Android 64-bit support is actively in the works for Delphi as we speak. In time for this new Google requirement, we plan to kick off our 10.4 beta this summer with support for building Delphi Android 64-bit applications. While the usual beta restrictions do not allow for building and deploying production apps, we intend to include a special beta EULA provision that allows 10.4 beta testers to deploy (production) Android apps to the Google Play Store. We followed the same approach for 10.3 and Google’s API level 26 requirement last summer and that process worked well for our customers. InterBase support for Android 64-bit is also in the works.”

Bottom line is that Delphi 10.3.x Rio and C++Builder 10.3.x Rio 32-bit apps can continue to be deployed via Google Play using android:maxSdkVersion=”27″ to 90% of Android devices and Embarcadero has Android 64-bit support for Android 9 Pie (Android 28+) devices on their roadmap.

Head over and check out the full blog post about the Embarcader RAD Studio Roadmap and future Android 64-bit support.

RAD Studio 10.3.2 Rio (Delphi + C++Builder) has been released with some significant enhancements to the Firemonkey framework. 10.3.2 includes a new MacOSX 64-bit compiler to satisfy new Apple requirements for desktop development. Shortly before the release of 10.3.2 FMXLinux was made available via GetIt as well bringing Firemonkey to Linux (and HTML5). This means that the target platforms that Firemonkey currently officially supports are now Windows 32-bit, Windows 64-bit, MacOS 32-bit, MacOS 64-bit, Android 32-bit, IOS 32-bit, IOS 64-bit, Linux 64-bit, and HTML5 (through web sockets). That is a pretty impressive target platform list to be able to deploy to with a single UI and single codebase using natively compiled code.

Items from the release that related to cross platform Firemonkey are:

• FireMonkey styles performance optimization
• Better FullScreen mode on iOS including visible status bar
• Android FireBase Support
• Android Improvements to icons for all notifications.
• Updates to Google Play services and Maps to match Firebase version support requirements.
• Firebase replaces Google Cloud Messaging (deprecated by Google).
• FireMonkey Linux provides the ability to create GUI applications for Linux,
• Improvements in FMX support for the macOS platform, for both 64-bit and 32-bit apps.
• TEdit improvements on Android.
• Improved compatibility with older versions of Android.
• TMediaPlayer quality on Android and Windows.

The list of fixes applied to FireMonkey 10.3.2 are as follows:

Check out the full list of over 400 fixes for Delphi 10.3.2 FireMonkey on Android, IOS, OSX, Windows, Linux, and HTML5!

Developer David Nottage has released a free IDE Expert plus MacOS companion app for Delphi 10.3.2 to enhance the management of SDKs within the IDE, enhance the management of PAServer on MacOS, and tweak IOS deployment in Delphi 10.3.2. It has an expert which gets installed into the IDE and then it also has a companion app that runs on your Mac for managing SDKs. The features that Mosco lists are:

• An much enhanced experience of adding frameworks to SDKs (lists all available public frameworks in the SDK)
• Instantly switch between SDKs, including for macOS, iOS and Android
• Instantly switch between connection profiles
• Open Finder on the Mac to show where the deployed app is located
• Prompt when attempting to launch an app on an iOS device when the device is locked
• Alternative to PAServer Manager allowing you to manage multiple versions of PAServer on the Mac

Head over and check out the full blog post about the Mosco expert and then download it!

or

Head directly to GitHub and download the Mosco IDE Expert + companion app.

There are 50 new cross platform samples for Delphi 10.3 Rio FireMonkey available over on Github. The demos heavily feature low code ways of using components to do more with less code. The samples cover everything from JSON and XML to REST and the device Camera. Additionally, they cover things like asynchronous HTTP requests, animations, LiveBindings, grids, drawers, and much more. The demos are available to deploy on Android, IOS, MacOS, Windows, Linux, and HTML5. The source code is freely available under a BSD license. LiveBindings and TFDMemTable components are used throughout most of the samples. Some samples are more extensive like the BubbleChatApp, the Camera sample, and the ToDoList demo. If you are just getting into FireMonkey development with Delphi or you are an old hat with Delphi there is something here for everyone. The TShadowEffect is used and examples of various Material Design elements are also visible in the demos. Some of the icons are from Material.io while some of the images used are from the Pexels site. Elements from other development tools like Cards, AppBars, BottomSheets, and Stateful controls are also demonstrated. The code used in the samples is Object Pascal but the same concepts can be used in C++Builder’s FireMonkey with the sample code easily translatable to C++. If you test these demos and have fixes on specific platforms you can contribute the fix back to the repo. Here is the full list of demos.

01-HelloWorld
02-HelloWorldStyled
03-StatelessCards
04-StatefulControl
05-OnChangeTracking
06-OnClick
07-SimpleTabs
08-FrameTabs
09-AsyncREST
10-StringGridWithJsonData
11-DrawerMenu
12-PlatformMenu
13-Animation
14-JSONStorage
15-BubbleChatApp
16-ChangeGlyphColor
17-ToggleButton
18-ButtonOnClick
19-IconButton
20-UpdateEditField
21-UpdateCheckBox
22-UpdateRadioButton
23-UpdateSwitch
24-UpdateScrollBar
25-UpdateDateEdit
26-ToolBar
27-FloatingActionButton
28-PopupMenuButton
29-FooterButtons
30-CustomFooterTabs
31-BottomSheets
32-SnackBar
33-ShowMessageDialog
34-OptionsDialog
35-RowsAndColumnLayout
36-Cards
37-Alignment
38-ListViewFromJson
39-ListViewFromStringList
40-DataImage
41-Fullscreen
42-TestConnection
43-Dial
44-TodoList
45-Calendar
46-Splitter
47-ProgressBar
48-ImageViewer
49-Camera
50-XML

Head over and check out all of the Cross Platform Samples for Android, IOS, MacOS, Windows, Linux, and HTML5.

RAD Studio 10.3.3 Rio (Delphi + C++Builder) has been released with some significant enhancements to the Firemonkey framework. 10.3.3 includes a new Android 64-bit compiler to satisfy new Google Play requirements for deployment. This means that the target platforms that Delphi Firemonkey currently officially supports Windows 32-bit, Windows 64-bit, MacOS 32-bit, MacOS 64-bit, Android 32-bit, Android 64-bit, IOS 32-bit, IOS 64-bit, Linux 64-bit, and HTML5 (through web sockets). That is a pretty impressive target platform list to be able to deploy to with a single UI and single codebase using natively compiled code.

Items from the release that related to cross platform Firemonkey are:

• Android 64-bit support for Delphi.
• iOS 13 and macOS Catalina (Delphi) Support.
• Camera fixes and enhancements on Android
• Support for Android 10, including specific improvements for the splash screen
• Improved support for editing, virtual keyboard, and IME for iOS 13
• Push notification improvements on iOS
• App Tethering: Improved stability, error handling, and enhanced samples
• FireDAC Fixes and updates
• macOS 64 Notarization and RTTI enhancements

The list of fixes applied to FireMonkey 10.3.3 are as follows:

Check out the full list of hundreds of fixes for Delphi 10.3.3 FireMonkey on Android, IOS, OSX, Windows, Linux, and HTML5!