Delphi 10 Berlin has a SdkTransform tool which creates Object Pascal header files for the IOS SDK. There is a GUI tool which wraps around the command line tool for generating the files. I went ahead and added all of the IOS 9.3 frameworks to Delphi 10 Berlin and then applied the SdkTransform tool to them. The resulting Object Pascal files have been added to a Github repository. This saves you from having to do it yourself but it also makes them searchable. You may find something in there you didn’t even know you were looking for. This is the full list of frameworks: AVFoundation, AVKit, Accelerate, Accounts, AdSupport, AddressBook, AddressBookUI, AssetsLibrary, AudioToolbox, AudioUnit, CFNetwork, CloudKit, Contacts, CoreAudio, CoreAudioKit, CoreBluetooth, CoreData, CoreFoundation, CoreGraphics, CoreImage, CoreLocation, CoreMIDI, CoreMedia, CoreMotion, CoreTelephony, CoreText, CoreVideo, EventKit, EventKitUI, ExternalAccessory, Foundation, GLKit, GSS, GameController, GameKit, HealthKit, HomeKit, IOKit, ImageIO, JavaScriptCore, LocalAuthentication, MapKit, MediaAccessibility, MediaPlayer, MediaToolbox, MessageUI, Metal, MobileCoreServices, MultipeerConnectivity, NetworkExtension, NewsstandKit, OpenAL, OpenGLES, PassKit, Photos, PhotosUI, PushKit, QuartzCore, QuickLook, SafariServices, SceneKit, Security, Social, SpriteKit, StoreKit, SystemConfiguration, Twitter, UIKit, VideoToolbox, WebKit, and iAd.

Obviously these are only for IOS but if you want the Android SDK headers in Object Pascal they are also on Github.

Head over and download all of the IOS 9.3 SDK frameworks in Object Pascal for Delphi 10 Berlin.

Developer Aone Chen out of China has released utility for creating your own Firemonkey style theme. The utility is built in Firemonkey and allows you to preview the theme within it. The utility can load both style files and binary style files. The built in color adjuster within the utility allows you to create a new style for any of the platforms supported by FMX which are Android, IOS, OSX, and Windows. Once you create a new style you can apply the color filter and then save the style out for usage in your own app. The utility supports the various different screen resolution ratioswhich are listed as 1, 1.5, 2, and 3. The blog post about the utility is in Chinese so be sure to use a translator if you need more information about the utility. The utility is free but source code for it is not included. The style files should also work with C++Builder. Try this style utility with the Premium Styles too.

Head over and download the Firemonkey theme utility for Delphi 10 Berlin.

Mirror: Download the theme utility directly from this mirror.

Developer Alexander Sviridenkov has updated his HTML Component Library for Delphi Berlin, adding many functionalities and various optimizations. From the most important features added in this version (3.6), we have to mention: New powerful cross-platform scripting engine, Added support for CSS visibility, table-layout properties, Added more events to THtDocument component (ThtDocument.AfterImageLoaded, THtDocument.OnAnimationEnd and THtDocument.AfterControlCreated), Instant support for Font Awesome (Android and Web developers should be familiar with this nice set of icons), support for element sorting, improved HTML Report Library (Added report-objects element – create report objects inside report from SQL, expression or script, added Side-by-side bars chart, Area charts), new component introduced – THtReportPanel and many others. Also, the library was optimized by improving the parsing and compilation speed and making style calculations faster. New demo projects are available to test these awesome new features and improvements. One more important thing to mention, HTML Editor Library has now support for IOS and Android. This is a commercial library but there are demos for you to check out which work on Windows, Android, and Mac OSX. Additionally, there is a trial version which you can test yourself to see if it fits your needs.
Head over and check out the free trial of the HTML Component Library for Delphi Firemonkey on Android, IOS, OSX, and Windows.

RiverSoftAVG released an amazing multimedia add on package for their RiverSoftAVG SVG component library. This add on contains instrument multimedia components which are high quality, high resolution and easily customizable. This component library is available for Delphi Berlin on Windows, OSX, Android, IOS for both VCL and FMX. The suite contains over 15 gauges and gadgets, including clocks (TRSClock, TRSCircularClock, TRSDigitalClock), compasses (TRSCompass and TRSCircularCompass), batteries, speedometers, lights, an altimeter (TRSCircularAltimeter) and a barometer (TRSCircularBarometer). For the developers who are interested in the library architecture, the full source code is provided, the components are resolution independent with a small footprint for your applications and no other external files are required. When it comes to implementation, the library provides the developer integrated IDE Help Insight as well as Help File and Online Documentation. Please note, that in order to use these amazing components, you are required to install RiverSoftAVG SVG Component Library or buy IMPACT as a bundle with the SVG library. Demos are provided, with no limitations to test the full features of the library. When demos not running within the IDE, a nag screen will be displayed. Apart from the multimedia package, RiverSofAVG library also contains some very useful components like: Inference Engine Component Suite, Fuzzy Logic Component Library, Genetic Algorithms & Programming Component Library, very handy when you have projects dealing with Artificial Intelligence. RiverSoftAVG is a commercial package has a decent cost to it but the site license is much more expensive. Additionally, you have the option to buy the components individually or to buy them for a certain IDE. This last option is much cheaper and tailored to everyone’s needs.

Head over to check out the amazing RiverSoftAVG IMPACT available for Delphi Berlin (Win32/Win64/OSX/iOS/Android).

Developer rzaripov1990 has a custom ListView component over on Github for Firemonkey in Delphi 10 Berlin. The ListView is the central component for every mobile application, and as a developer you should always choose the one that can be heavily customizable and very easy to use/implement. This modern ListView component is available for Delphi 10 Berlin with FireMonkey on Android, IOS, OSX, and Windows. One nice feature is that it has both horizontal and vertical mode. Thus, using ListView.Horizontal := true, enables the list to display the cells (items) in a horizontal perspective, while ListView.AutoColumns := true (default behaviour) displays the items vertically. If you are an artist when designing your look and feel of the application, this component can customize every graphic aspect such as: SetColorItemSelected, SetColorItemFill, SetColorBackground, SetColorItemSeparator, SetColorText, SetColorTextSelected, SetColorTextDetail, SetColorHeader, SetColorTextHeader, and many other properties. The properties are self-explanatory, no need to cover them here. With the AutoColumns and ColumnWidth properties, the component will automatically calculate the best fit appearance and position for the items when populating the list (very useful when dealing with large number of items). Apart form the standard behavior events, you have OnColumnClick listener for the ListView. You also have the option to hide/show the scroll bars (ListView.ShowScrollBar), set indent for items separators (ListView.SeparatorLeftOffset and ListView.SeparatorRightOffset). The component is free and has some nice demos with it as well. For the moment it is available only for Delphi Berlin and FireMonkey, very useful if you build multi-device applications.

Head over to check out this amazing ListView component available for Delphi Berlin and FireMonkey.

Developer gmurt with Kernow Software released an update for its custom FMX component suite over on Github. At the core, there are the ListView and Slide-Menu, two powerful components which have a large palette of uses in your applications. You can use these components on Android, IOS, OSX, and Windows. The component suite comprises: TksTableView, TksSlideMenu, TksSegmentButtons, TksTabControl, TksNetHttpClient, TksTileMenu, TksChatView, TksSpeedButton. TksTableView is useful when displaying grid like information (think of TStringGrid components from Delphi) and the performance is quite staggering regardless of the number of text/items/graphics added. Supports various embedded components like switches, buttons and segment buttons, can be used as a check list or multi check list. Also, it supports image cropping (square, round rect or circle), indicators and “sticky” headers. TksSlideMenu, apart form standard properties, has fading background effect and bitmap caching for optimized performance, also it inherits from non-visual TComponent for quick integration into existing projects. TksSegmentButtons supports IOS style badges. For those of you who need a powerful HttpClient, TksNetHttpClient is the right solution enhanced with an ASync Get method. If you are in need of building a fast chat module for you application, you can always use TksChatView with IOS style. Components can be used in Delphi 10 Berlin with FireMonkey. Sample implementations for each component are provided, for both Delphi and IOS to ease the development time. All the component suite can be easily integrated in your applications at no costs as they are available on Github.

Head over to check out the high-performance component suite available for Delphi 10 Berlin and FireMonkey.

Developer WinSoft has released an updated version of the powerful PDFium component suite for managing PDF documents and it is now available for Firemonkey in Delphi 10 Berlin. With these components you can build applications that can view and edit PDF documents and extract text from PDF files using a straightforward and easy integration. At the core of this component suite lies the PDFium open source PDF rendering engine. The components are available for C++ Builder fans as well as supporting various platforms: Windows 32/64, OS X, IOS and Android. If you want to develop applications for Android, you have to deploy libapdfium.so file to library\lib\armeabi-v7a\. It is a commercial component suite. For those who want to study the code, the full source for the components is provided but only in the full version. If you want to try out this library demos for Delphi, FireMonkey, OS X and Android are ready for you to download. Also, once you purchase the library, you can use it freely in your applications at no other costs.

Head over and download the demos to check out the PDFium component suite available for Delphi Berlin, FireMonkey, IOS X and Android

Developer ZuBy has made some demo code available for changing the StatusBar color on Android in your apps. The status bar is the bar at the top of your device with the various icons and other information in it. In a Java based Android app to change StatusBar color you can do it either by modifying the styles.xml file and adding the following line: <item name=”android:statusBarColor”>@color/color_primary</item> or by changing at runtime (implementations may differ) through code using window.setStatusBarColor(activity.getResources().getColor(R.color.my_statusbar_color)). However, in FireMonkey you must use the JNI (Java Native Interface). JNI enables Java code running in a Java Virtual Machine (JVM) to call and be called by native applications (programs specific to a hardware and operating system platform) and libraries written in other languages. Thus, you can call JNI Java code from Delphi 10 Berlin with FireMonkey and make the necessary changes. In order to make use of this change, make sure you are using Android 5 (Lollipop) and above. This code does not apply to Windows, IOS, or OSX. Notice that the code bellow is very similar to the Java implementation on Android.

procedure StatusBarSetColor(const aColor: TAlphaColor);
{$IFDEF ANDROID}
var
  Window: JWindowExt;
{$ENDIF}
begin
{$IFDEF ANDROID}
  CallInUIThread(
    procedure
    begin
      if TOSVersion.Check(5, 0) then
      begin
        Window := GetWindowExt;
        Window.addFlags(TJWindowManager_LayoutParams.JavaClass.FLAG_TRANSLUCENT_STATUS);
        Window.addFlags(TJWindowManager_LayoutParamsExt.JavaClass.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);

        Window.setFlags(TJWindowManager_LayoutParams.JavaClass.FLAG_TRANSLUCENT_STATUS,
          TJWindowManager_LayoutParams.JavaClass.FLAG_TRANSLUCENT_STATUS);
        Window.setFlags(TJWindowManager_LayoutParamsExt.JavaClass.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS,
          TJWindowManager_LayoutParamsExt.JavaClass.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);

        Window.setStatusBarColor(TJcolor.JavaClass.TRANSPARENT); );
      end;
    end);
{$ENDIF}
{$IFDEF IOS}
  SetStatusBarBackgroundColor(aColor);
{$ENDIF}
end;

Head over to checkout the full demo on how to change the StatusBar color in Delphi 10 Berlin with FireMonkey

Edit: For changing the StatusBar color on IOS check out this Github code.

Developer TMS Software released an update for their nice Cloud Services component suite for Delphi Berlin and FireMonkey with two new additions: TTMSFMXCloudMSComputerVision and TTMSFMXCloudMSBingSpeech. Among the other Cloud Services, the developer can access Google Services (Calendar, Contacts, Drive, Mail, Photos etc.), Social media services (Facebook, Twitter, LinkedIn, YouTube etc.) and payment services (PayPal). The TTMSFMXCloudMSComputerVision uses Microsoft Computer Vision powerful algorithms to analyze information about the visual content found in an image. You can categorize and analyze many types of images starting with facial recognition, reading text in images, license plate recognition to even real time video analysis and much more. The TTMSFMXCloudMSBingSpeech helps you speech read a text, which is a very useful feature for visual impaired people and in combination with image content analysis to offer them a real image of the world. The implementation of these two components is straightforward and it takes less than 15 minutes. Use TTask component to avoid blocking the main application thread. In order to use them in your applications, you have to register to with Microsoft Cognitive Services in order to get an Api key. If you use the free plan, Microsoft offers you 5,000 transactions per month. If you require more for your business, choose the standard paid plan. You should be able to use these components across Android, IOS, OSX, and Windows. The components are licensed and you have to buy them in order to use them in your applications, single license being the most convenient option. If you want to first test the performance and results, free demos are provided and you can download them.

Head over and check out the free trial and demos for TMS FMX Cloud Pack for Delphi 10 Berlin and Firemonkey.

Developer MedicalEffect  has a DICOM component now available for FireMonkey in Delphi 10 Berlin which gives you the possibility to build powerful medical applications. DICOM (Digital Imaging and Communications in Medicine) is a standard for handling, storing, printing, and transmitting information in medical imaging. It includes a file format definition and a network communications protocol. The component is written in Object Pascal, no other files or libraries are required to deploy with your application and it follows the latest DICOM standard (DICOM 3.5). It supports Windows, OS X, Android and IOS and it comes with an integrated DICOM viewer and communication interface. The component is not free, various licensing options are available: from single developer license (the cheapest and most convenient) to site license with source code. After purchasing, you can include this component in your applications at no other costs. Free trial version is available and it includes demos for all platforms (DICOM viewer, DICOM server). Also, it has DIMSE-C (PACS/DICOM Server) in case you have many medical devices and you require a centralized solution to manage them all. Also it has up to date documentation and manual which gives you easy and fast integration.

Head over to check out the full features of this component for FireMonkey in Delphi 10 Berlin.

Developer David Nottage proposes a nice solution to keeping your applications to run in the background on iOS. On iOS as well as on Android, it is the system that decides when to terminate an app for very specific reasons (i.e. memory starvation). For this particular reason, the onClose event of the app might not trigger, since the system decides to immediately kill the application. Thus, you should never place important code in this event, since it will not execute and even worse you could cause memory leaks if you try to free the memory in the onClose event and this event is not fired. Suspended applications receive no notification when they are terminated unlike the applications that run in the background and are not in the suspended state. In this case, the system calls applicationWillTerminate before the actual onClose event. In Delphi, in the case of UIApplication, two important methods have been left out:

function beginBackgroundTaskWithExpirationHandler(handler: TBackgroundTaskHandler): UIBackgroundTaskIdentifier; cdecl;
procedure endBackgroundTask(identifier: UIBackgroundTaskIdentifier); cdecl;

The demo, wraps the two methods and provides easy and convenient integration. The implementation applies to Delphi 10 Berlin with FireMonkey. Here is a small sample of the demo implementation, just to give an idea and stir your interest to study it in more detail. This method is not related to UIBackgroundModes.

function TBackgroundTaskManager.Start: Boolean;
begin
  FTaskID := SharedApplication.beginBackgroundTaskWithExpirationHandler(DoExpiry);
  Result := IsValidTask;
end;

procedure TBackgroundTaskManager.Stop;
begin
  if IsValidTask then
    SharedApplication.endBackgroundTask(FTaskID);
  Reset;
end;

Head over and check out the demo for IOS Background Applications for Delphi Berlin with FireMonkey.

Mirror: Download the background IOS demo for Delphi 10 Berlin.

Developer David Nottage proposes an interesting solution to a problem some of you might have noticed on FireMonkey when switching to iOS 9 or higher, in particular the Location Sensor stops working when the application is in background. The reason behind this behavior is that Apple introduced a new required property – allowBackgroundLocationUpdates to be set on CLLocationManager. Also you have to include location UIBackgroundModes in the project options. In order for the Location Sensor to work in the background you have to always pass True to requestWhenInUseAuthorization method. In order to make this change, you have to modify the implementation sections of the units: iOSapi.CoreLocation and System.iOS.Sensors and completely redeclare CLLocationManager here, and add the new methods for the property.

Here is some sample code:

type
  // Reintroducing the entire CLLocationManager and CLLocationManagerDelegate in order to add allowsBackgroundLocationUpdates property
  CLLocationManager = interface(NSObject)
    ['{B162A514-4334-48B8-B31A-32926B758340}'] // New GUID
    function activityType : CLActivityType; cdecl;
    procedure allowDeferredLocationUpdatesUntilTraveled(distance: CLLocationDistance; timeout: NSTimeInterval); cdecl;
    function allowsBackgroundLocationUpdates: Boolean; cdecl; // New method for allowsBackgroundLocationUpdates property
    function delegate: Pointer; cdecl;
// snip
    procedure setActivityType(activityType: CLActivityType); cdecl;
    procedure setAllowsBackgroundLocationUpdates(allowsBackgroundLocationUpdates: Boolean); cdecl; // New method for allowsBackgroundLocationUpdates property
    procedure setDelegate(delegate: Pointer); cdecl;
// snip
  end;
  TCLLocationManager = class(TOCGenericImport<CLLocationManagerClass, CLLocationManager>)  end;
 
  CLLocationManagerDelegate = interface(IObjectiveC)
    ['{113A227F-AD2D-4983-83C3-C5158F394257}'] // New GUID
    procedure locationManager(manager: CLLocationManager; didFailWithError: NSError); overload; cdecl;
// snip
    [MethodName('locationManager:didFinishDeferredUpdatesWithError:')]
    procedure locationManagerDidFinishDeferredUpdatesWithError(manager: CLLocationManager; error: NSError); cdecl;
  end;

If you want to always set the authorization for allowsBackgroundLocationUpdates not only when the sensor is active, you have to modify TiOSLocationSensor.DoStart method.

if TOSVersion.Check(9) and (FLocater <> nil) then
  begin
    {$IF Defined(BACKGROUNDUPDATES) and Defined(CPUARM64)} // for some reason, this function crashes in 32-bit
    FLocater.setAllowsBackgroundLocationUpdates(True);
    {$ENDIF}
  end;
  // check authorization
  if Authorized = TAuthorizationType.atUnauthorized then
    SensorError(SLocationServiceUnauthorized);
// snip

Head over and check out the demo for Using Location Sensor in Background for Delphi Berlin with FireMonkey.

Mirror: Download the background location sensor demo for Delphi on IOS.

Developer Luxophia on Github released an implementation of the TriFlip model available for Delphi Berlin and FireMonkey. The Torus is an OBJ file and the texture is a BMP file. The demo is for Win32 and Win64 but it works on Android, IOS, and Mac OSX with some changes. There is some inline assembly code that can be commented out and some other changes to make it multi device ready. The TriFlip model is actually a data structure that holds the information about the triangular faces of each polygon adjacent to each other. This feature allows the model to perform Euler operations (cut or combine polygons). In solid modeling and computer-aided design, the Euler operators modify the graph of connections to add or remove details of a mesh while preserving its topology. The boundary representation for a solid object, its surface, is a polygon mesh of vertices, edges and faces. It’s topology is captured by the graph of the connections between faces. A given mesh may actually contain multiple unconnected shells (or bodies); each body may be partitioned into multiple connected components each defined by their edge loop boundary. To represent a hollow object, the inside and outside surfaces are separate shells. In Geometry, Euler operators modify the mesh’s graph creating or removing faces, edges and vertices according to simple rules while preserving the overall topology thus maintaining a valid boundary (i.e. not introducing holes). The TriFlip model implementation is provided as a demo for you to try out in FireMonkey under Delphi 10 Berlin.

Head over and check out the library and demo TriFlip Model for FireMonkey in Delphi 10 Berlin.

Developer David Nottage proposes a slick solution to background fetches on iOS, by decoupling the method calling the completion handler from the actual background fetching code. Background fetches were introduced in iOS 7 and can be used to fetch small amounts of data for a limited time (30 seconds) when the application is in background (i.e. to check if the user has new mail messages). In order for applications to be enabled for background fetch, the “fetch” option needs to be checked in the UIBackgroundModes key in the Version Info section in the project options. The method that handles the background fetching, on iOS, is called performFetchWithCompletionHandler. In FireMonkey, there is no such method, however you can add missing methods to the application delegate, using the Objective-C runtime function class_addmethod.

class procedure TPlatformBackgroundFetch.performFetchWithCompletionHandler(self: id; _cmd: SEL; application: PUIApplication; 
  completionHandler: id);
var
  LResult: TBackgroundFetchResult;
  LPlatformResult: NSUInteger;
begin
  if FFetch <> nil then
  begin
    // Assume no data
    LResult := TBackgroundFetchResult.NoData;
    // Call the handler if assigned
    FFetch.DoFetch(LResult);
    LPlatformResult := BackgroundFetchResultToPlatform(LResult);
    // The completion handler *must* be called, if the app is continue to receive background fetch messages
    CallBlockImplementation(self, _cmd, completionHandler, LPlatformResult);
  end;
end;

You can also set the fetch interval with setMinimumBackgroundFetchInterval, however you should not that the maximum time amount is 30 seconds.

procedure TPlatformBackgroundFetch.UpdateFetchInterval;
begin
  SharedApplication.setMinimumBackgroundFetchInterval(CocoaDoubleConst(libUIKit, 'UIApplicationBackgroundFetchIntervalMinimum'));
end;

The demo project implements the background fetch as a platform service (makes use of TPlatformServices), it sets the OnFetch handler, and you have to provide an implementation for it.

Head over and check out the demo for Background Fetches for FireMonkey in Delphi 10 Berlin on IOS.

Mirror: Download the background fetch demo project for FireMonkey in Delphi on iOS

Developer TMS Software released their amazing framework code-named Aurelius, an ORM (Object Relational Mapping) now available for FireMonkey and Delphi 10 Berlin. This powerful framework lets you easily integrate database in your applications. It supports several database servers (MS SQL Server, Firebird, MySQL, DB2, Interbase, Oracle and many other) and several database-access components (dbExpress, AnyDac, SQLDirect, ADO, IBX and many others). You are no longer required to test your complex SQL statements at run-time, since we are now dealing with entity objects in an object-oriented way. When writing queries, Aurelius provides a robust query API using criteria expressions, projections, grouping, conditions and even logical operators in a LINQ-like approach. You also benefit from the OOP concepts and you can make use of inheritance mapping and polymorphism – map a full class hierarchy into the database. At the core of the framework lies TaureliusDataSet, which can be easily integrated with the existing DB-aware controls in VCL, thus making this framework independent of the database engine and components you use as a developer, and you can write the same code to manage multiple databases in a transparent way. Aurelius framework is a multi platform solution – available on Windows 32/64, macOS, iOS and Android. As a developer, you can choose from the free version (only available for Delphi Berlin) and the paid version which is available for older versions of Delphi and you have access to source code and also gives you fast support from the TMS team.

Head over and check out the free trial and demos for TMS Aurelius ORM Framework for FMX and Delphi Berlin

Developer Big Banng over on the Google+ Group posted a free utility for generating icons for your Delphi 10 Berlin apps on Android and IOS. When you write your applications for mobile or Windows, I’m sure you found yourself in a bit of trouble when it came to creating icons or splash screens. Whether you create application icons or icons for your app navigation/toolbar or just a fancy splash screen, you would want something easy, something that has as input of an image and which can output icons with various resolution to be used on the spot. Put aside your Adobe Photoshop skills, you now have this simple application, Delphi 10.1 Berlin Icons Generator, with simple interface and with just one click you are able to generate a whole set of icons for various resolutions or a splash screen. All you have to do, it to load an image and to select what you want to export: icons or splash screen. This tool has easy to use and modern interface, it will generate over 25 images from the base image, with resolutions ranging from 36×36 up to 255×255 pixels. You can generate image resources for Android and IOS as well as for Windows. The most useful feature is the Vector Graphics generator. Same as the icon generation process, you load an image file and it will generate vector graphics files ready to be used in your applications. This utility is now free and it will generate all the icons/images resources you will ever need for your application with just one click. Thomas Grubb also has a free utility to do this.

Download the free icon and splash screen generator app for Delphi 10 Berlin.

Update: The original version of this was packed with UPX and flagged as a virus. Apparently this is a new version that is not packed with UPX.

Delphi with the FireMonkey framework is a great tool to quickly build REST clients. I wanted to build out a Delphi project to go along with the Christmas holiday and I came up with a project where I combined the REST Client in Delphi with the Open Movie Database REST API to display Christmas movies. There is a blog post of the whole build over on the Embarcadero Community site which explains it in detail. The FireMonkey client should run on Android, IOS, MacOSX, and Windows. Source code for the full project is up on GitHub for free. In the project there are some good concepts explored like: downloading an image from a URL and displaying it, using FireMonkey premium styles to theme out the app, dynamically displaying image content and paging through it, dynamically configuring the display of content based on the device, deploying the TTabControl as a view controller, using TFrame to visually build out a re-usable component, utilizing the low code LiveBindings to display a lot of content quickly, and automatically importing JSON from the REST API to a TFDMemTable. You should be able to use these same concepts in C++Builder as well. If you are looking to consume your own REST API with Delphi be sure to read the full blog post and check out the source as there are some nice pointers in there on what worked for me.

Head over and check out the full blog post about building out a REST Client with Delphi FireMonkey.

Calculating fields together with LiveBindings in Delphi FireMonkey can be a good low code alternative to writing a bunch of code to do the same. LiveBindings makes it relatively easy to add fields together using it’s CustomFormat property. LiveBindings supports a wide variety of operations in the CustomFormat property can you can check out more information about that in the Embarcadero DocWiki. There is a demo with this post that shows how to add three fields together and output the result to a fourth field. You should be able to use the demo cross platform on Android, IOS, OSX, and Windows. The demo uses components from the TMS FMX UI component set but the components are probably not required if you implemented these ideas in your own app. There is a TFDMemTable in the project with 4 fields called FieldEdit1, FieldEdit2, FieldEdit3, and FieldEdit4. The four fields are bound with LiveBindings to 4 edit controls called Edit1, Edit2, Edit3, and Edit4. You can also see the contents of the TFDMemTable in the featured TTMSFMXLiveGrid. Entering number values into any of the Edit1, Edit2, and Edit3 controls will add those 3 values together and give you a final value in the Edit4 control. You can see that when you add values into the Edit1, Edit2, and Edit3 controls that the value is automatically updated in the TFDMemTable. Finally, pressing the included Save button will store the calculated value from the fourth Edit4 control into the TFDMemTable as well. In the calculation demo the LinkControlToField1.CustomFormat property is set as the following:

IfThen(Self.Owner.FieldEdit1.AsString=”, 0, Self.Owner.FieldEdit1.AsFloat)+
IfThen(Self.Owner.FieldEdit2.AsString=”, 0, Self.Owner.FieldEdit2.AsFloat)+
IfThen(Self.Owner.FieldEdit3.AsString=”, 0, Self.Owner.FieldEdit3.AsFloat)

Note: Self.Owner.FieldEdit1, Self.Owner.FieldEdit2, Self.Owner.FieldEdit3
are the names of the fields in the TFDMemTable.

The reason it uses the IfThen() function is to keep any conversion errors from happening. If it’s blank use zero otherwise use the field value. The TTMSFMXEdit is setup to only allow number characters.

LiveBindings is built into Delphi and C++Builder so you can use it out of the box in all of your latest applications.

Download the full demo of the LiveBindings calculation example for Delphi Firemonkey on Android and IOS

Embarcadero has released a Hospitality Survey App template for Delphi 10.2 Tokyo through their GetIt platform. The Hospitality Survey App consists of four different projects. A client app built with FireMonkey for Android, IOS, OSX, and Windows where users can fill out survey information. A web app built with AngularJS for viewing survey stats. A REST server built with RAD Server for Windows and Linux. And a setup app which is used to configure the whole system. You can customize the questions during the setup process but not afterward. What is missing from these four projects is a way to edit the dynamic form questions on the server after you deploy the template to production. I have created a Hospitality Survey Editor app which will connect to your existing Hospitality Survey database and allow you to customize the questions which are asked in the client. The questions are stored in a table in the database and then downloaded to the client as JSON through RAD Server. The Hospitality Survey Client app loads the JSON and then dynamically creates the input fields using TFrames. The Hospitality Survey Editor app was created by stripping down the Hospitality Survey Setup app and connecting it directly to the Hospitality Survey database. Here is a list of the dynamic fields that you can customize in this new editor:

ID – An ID for the question. You should increment the number of the ID for each new question you add.
name – A short name for the question with no spaces.
title – The text of the question as it will appear in the survey.
type – The type of question controls which question template is loaded on the client. The existing types are: rating, yesno, edit, options
options – If the type of the question is set to options this field is used to populate the options. It’s value is a JSON array of options.
value – The value is where the user submitted data is stored. It can be left blank but could be used to provide a default answer.
category – The category of the question. This field is provided for expandability.
tenant_id – The tenant ID of the question. If the tenant_id field is blank all tenants will get the question. If it is set to a tenant only that tenant will get the question.

Download the full source code for the Hospitality Survey Editor in FireMonkey for Delphi 10.2 Tokyo.

Note: You need the Hospitality Survey Template from GetIt to be able to use this.

Embarcadero has four mobile arcade game projects for Delphi in Object Pascal available for free over on GitHub. All of the projects run on Android, IOS, OSX, and Windows. One of the projects is called Space Rocks and I modified this project to allow the player to customize the game at runtime (for more info about Space Rocks check out this blog post). The modified game is called Deep Space Rocks. I also re-skinned the game a but with a new background, player character, and enemy characters. The new Customize Game functionality that I added to the project allows you to modified the following settings at runtime: Player Image, Enemy Image, Asteroid1 Image, Asteroid2 Image, Asteroid3 Image, Powerup Image, Background Image, Player Health, Collect Item Duration, Collect Item Speed, Rock Speed, Enemy Proj Speed, Enemy Speed, Player Proj Speed, Player Fire Speed, Player Rotation Speed, Player Speed, and Player Lives. This allows the player to tweak the settings and play it how they want to play it. It also allows you to easily play test and tweak the game yourself to get the best settings. Allowing players to customize your game like this can increase player retention of your game. The player customize-able settings could also be expanded to include more settings like the sound and music. Full source code is provided for this modified version of the game.

Download the full source code for the runtime customizable Deep Space Rocks game in FireMonkey for Delphi 10.2 Tokyo.