FDK - THE FireMonkey Development Kit

Would you like to develop a cross platform app, but not start at zero?
Are you missing the right entry to create an app for iOS or Android?
We have the solution!

Are you still working with VCL? For VCL developers the FDK offers many helpful Units,too!

What is the FDK? 
What can I do with it?


The order can simply be executed via the setup program, as it has its own shop integrated!

The price of the full version (Source) is 399,- € and 199,- € for an update. Further information about the FDK: on my blog
Download: HERE
Questions: frank at delphiprofi dot de


Since Delphi XE2 it is also possible to create mobile applications (iOS), since XE4 also for Android. It quickly became clear that app development with Firemonkey is not only a bit different, but it also depends on a lot of research. So the obvious way to do that was to create a UNIT and put everything into this unit that was needed for mobile app development.

Since all forms are always displayed in full screen on the mobile devices, first of all a window manager had to be created. Also, you quickly realize under Firemonkey that the styles only work properly, and this is especially true for click events when you leave the UI task (main thread) all the time that is available. This also means that you should by no means insert something into a button click event that costs time at all. So once you've determined that the user pressed the button, the flowcontrol must be returned to the main thread as soon as possible. But when can I call my action which the button should trigger? The answer is either I'm doing it in a thread or I'm waiting for the application to trigger the onIdle event. This is actually the magic of FMX app development. Of course I have programmed a corresponding handler for this to handle this type of OnClick events. 

Countless units of the FDK are dealing with threading, generating elements at runtime, interface wrappers so you can test everything under Windows, because there is no ARC, and much more.
Another issue is certainly a simple use of the SQLite database preinstalled on the mobile platforms. The most common question asked is: How do I get my data from the mobile device to a server?

Normally you should use a REST service via JSON, so it was obvious to program corresponding methods. Numerous of there functionalities are now also available in nativ Delphi, but my wrapper are still easier to use. The best example is certainly the interface to query the "new" permissions on the Android platform. 

Newcomer to Firemonkey will certainly encounter problems in the beginning, eg the on-screen keyboard overlays the edit component. Again, there is a autoscroller component in the FDK.
All necessary settings, database connections and autoscrollers as well as the application events can be done with one line. At the moment I'm still working on a MVVM plugin for the FDK as well as on a Delphi-capable MVVM stand-alone implementation. 

Update 2.0 for the FDK is comming, too!


Overview of the units in alphabetical order. All units have the namespace "Delphiprofi.FDK. *. Pas". Units marked with (WIP) are currently under development. As time permits, I will link the documentation to this list. My singletons are all testable, because there is one BaseClass for each, which you can instantiate by yourself.
  • Amazon // Interface wrapper for Amazon-Cloud-Storage
  • AnyConverter // Generic singleton for converting from typeA to typeB
  • AnyFactory // Singleton factory - can create anything - incl. dependencies.
  • AppConfig // My version of an INI-file in the form of a SQLite-Database
  • AppEventLogger // Database based logger to record the events of the app
  • AppGlobal // Singleton for handling global instances
  • Async.Any // Generic worker class to perform "any" async processing
  • Async.JSONStore // Thread/Queed JSON->REST Database
  • Async // Worker, controller, async-base class
  • Attributes // Generic singleton handler. Class types can be registered and a handler can be called for each attribute.
  • BackgroundWorker // Handlers for background processing
  • Barcode // Interface-Wrapper for barcode reading Android & IOS
  • Calendar // Own calendar implementation with numerous (arbitrary) scaling and marking functions
  • CallByIDFactory // Depending on the ID (eg platform) the "correct" method will be called
  • Classes // Base classes for InterfacedObjects, classes with thread autoSync and interfaced debug classes.
  • Client.CRUD // Client part of the CRUD database
  • Client.JSONStore // Multi-Device, Multi-User, JSON-Database with autoupdate for alle subscribers (Client side)
  • Compressing // Interface for everything that needs to be packed and unpacked
  • Compressing.ZLib // ZLib implementation for compressing
  • Config // Interface for FDK settings and logging
  • Console // Console interface for logger incl. color output
  • Converters // Predefined converter for the AnyConverter
  • Crypting.FMXLockBox // Interface for LockBox (GetIt)
  • Crypting // Interface for everything that needs to be (en)(de)crypted.
  • DataStore // Threadsafe Warpper for Key-Value pairs and IDictionary implementation
  • DataView // Generic Interfaced Datacontainer
  • DTOWithVersion // Simple Key-Value JSON interface to Superobjects
  • Enumerables // Generic - Numerous extensions for enumerables and many predefined types
  • EventBus // implementation for request and background processing, MainThread sync and many more
  • Events // Application EventHandler
  • Exceptions.Handler // Application Exception Handler. Eg. for Logging or AppEventLogger
  • Exceptions // Own exceptions and all exception strings of the FDK
  • Factory // TDoubleDictionaryFactory
  • FireDAC.CRUD // CRUD interface for FireDac
  • FireDAC.Driver // Driver // Windows / OSX resources for SQLite / MySQL (MySQL-res not included)
  • FireDAC.ImportStream // Data Import Interface to import data from a desktop app
  • FireDAC.Journal // Journal generator for SQLite-Database I/O's
  • FireDAC.ORM // My ORM implementation
  • FireDAC // FireDAC Wrapper - No component needed on the form
  • FluentCreator // Generic Singleton for fluent generation of components at runtime
  • Fmx.Enumerables // Lists all components of an FMX form
  • FMXHelpers // Numerous useful FMX aids that have not found their own unit.

  • Formatter (WIP) // My own Delphi sourceCode formatter that is ABSOLUTELY freely configurable
    • Formatter.Composer // Registration of treatment routines
    • Formatter.Config.Delphiprofi // My own formatter settings
    • Formatter.Config // global settings
    • Formatter.Enumerables // lists of registering expressions
    • Formatter // Base methods
    • Formatter.Syntax // Syntax definition
    • Formatter.Tokenizer // Source-Tokenizer
    • Formatter.Types // Interface types and classes

  • FTP // Interface Wrapper for IdFTP
  • Generics.BlockingCollections // Threadsafe implementation for data lists / queue processing
  • Generics.Collections // Generic collection
  • HeartbeatWorker // Thread controlled EventTrigger
  • Helpers // General help methods that have not found a place in a separate unit
  • IdleWorker // Every FMX developer needs this handler who can record a quene of procedures and processes it.
  • IFDEF // Settings of the FDK
  • IO // Interfaces (IDriveInfo, IFileSystemInfo, IFileInfo, IDirectoryInfo)
  • Json // JSON und REST Helper / Interfaces
  • JSONStore // Definition of the JSONStore Records
  • Lang // Language resources for exceptions (de,fr,es,nl,ru,us) Google translated
  • Lists.Heap // IHeap sort
  • LocalWebModul // Debug Wrapper for locale webtests.

  • Logging
    • Logging.ConsoleLogger // Implementation for the console
    • Logging.DebugLogger // For output to the Debug-Console
    • Logging.FileLogger // For output to file
    • Logging.LogFilter // Filter to register types that should not be logged
    • Logging // Base implementation - THREADSAFE - All logging destinations can be used simultaneously.
    • Logging.ProcLogger // Logging informationen is forwarded to a procedure.
    • Logging.QueuedProcLogger // Threadsafe implementation that spares no time on the executing side
    • Logging.RemoteLogger // Logging output to a remote-server
    • Logging.SmartInspectLogger // Wrapper for log output to SmartInspect
    • Logging.TestInsightLogger // log output to TestInsight Console (from Stefan Glienke)

  • MainApplication // Base Implementation for Database, AutoScroller and much more. (Eg Android Hardware Back Button)
  • Messages // Wrappers for System.Messages with generic implementation and interface-based unsubscribe.
  • MulticastEvents // Std. Multicast Events e.g. for MVVM
  • MulticastEvents.Types // Types for multicast events
  • Neural // Simple neural network
  • ObjectPool // Treadsafe generic ObjectPool
  • Observer // Observer Interface and UISyncronizer Singelton.
  • Pattern.Internals // FDK extention of the singelton pattern
  • Pattern // Generic Singelton Implementation. Use each class as thread safes singelton.
  • Payment.Amazon (WIP) // Implementation for Amazon Payment - does not work yet
  • Payment.PayPal (WIP) // Implementation for PayPal Payment - does not work yet
  • Platform.Utils // Helper for the Plattform-Services
  • Push // Interface Wrapper for Pushnotification
  • Queues // Interface Wrapper for: Threadsave Queues, generic CommandProcessor, Multithreading CommandProcessors, Ring storage
  • Registry.Installer // Registry Interface for installer-entries in windows.
  • Registry // FDK Registry install-helper.
  • Resource.compressed // Handler for packed language resources
  • Resources // Handler for language resources / resourcenloader
  • REST // Interface for easy access to a REST (full) web server
  • RTTI // Everything you need for a smooth access to RTTI
  • Security.Win // HTTPS certificates Interface
  • Server.CRUD // Server side of the CRUD interfaces
  • Server.JSONStore // Server side of the JSONStores
  • Server.SQLHelper // FluidCreator for SQL statements (Basic)
  • Specifications // Basis Implementation
    • Specifications.Core // Generic interface for specification management
    • Specifications.Dates // Predefined specification for the date
    • Specifications.Strings // Predefined specification for strings
  • Stateless // Generic stateMachine implementation
  • Streams.Hashing // Stream Interface for the hashes in Delphi
  • Streams.Internals // Interface PersistentStream
  • Streams // Base multitype stream IO implementation. Packing, hashing, crypting
  • StringConsts // BaseType for ResourceStrings
  • TCPConnection.IO // TCP/IP Handler
  • TCPConnection // TCP/IP connection implementation
  • TCPConnection.SimpleTransfer // Simple TCP/IP transfer
  • Tethering (WIP) // Interface Wrapper for App-Tethering
  • Tethering.Queue (WIP) // Wrapper for Datatransfer with queue
  • Tethering.TransferObjects (WIP) // Transfering Objects
  • TextLayoutHelper // Justify Text wrapping Helper

  • Threading
    • Threading.AsyncAwait // AnsyAwait implementation
    • Threading.AsyncTasks // Async Task-Handler for Continuation
    • Threading // Helper for Threadsafe - Queue
    • Threading.Pipeline // Multi-Stage Pipeline Thread Management (One of the most powerful thread implemenations in FDK)
    • Threading.Serializer // Threading Serializer - eg For thread access to a SQLite database
    • Threading.SimpleThread // Numerous implementations for easy thread creation
    • Threading.Timers // Thread controlled timers
    • TimeoutWorker // Thread for the time(out) called of methods

  • TreeViewWalker // Generic class for easy access to a TreeView

  • Types (excerpt)
    • IDataView<T>
    • Tuple<T>
    • TVersion
    • Grouping<TKey,TElement>
    • Nullable<T>
    • TDateTimeValue
    • HelperForDateTime
    • PTypeHelper

  • Utils (excerpt)
    • TMethodRouter
    • TDelegateOnDestroy
    • TArray // Overload with countless functions
    • TTree<T>
    • With // Continuation with arguments
    • Sync // TMonitor helper
    • Switch<TResult>
    • Helper for interlocked

  • Vcl.Enumerables // Listed all components in a VCL form
  • WebLocal // Local webserver implementation for debugging.
  • Winapi.Windows // Wrapper for Windows API funktions.
  • WindowManager // Handler for form on form management (older)

Kontakt Informationen


Besuchen Sie und auf den diversen Plattformen.

Quick Contact

Email :

Infobase GmbH

Hostetstr. 153

52223 Stolberg (Rhld.)