FDK - Das FireMonkey Development Kit


Möchten Sie eine crossplattform programmiern aber nicht bei "null" anfangen?
Fehlt Ihnen der richtige Einstieg um eine App für iOS oder Android zu erstellen?
 Wir haben die Lösung!

Sie arbeiten noch mit VCL? Auch für VCL Entwickler bietet das FDK viele Hilfreiche Units!

Was ist das FDK? 
Was kann ich damit anfangen?

Bestellungen


Die Bestellung kann einfach über das Setup-Programm ausgeführt werden, da diese einen eigenen Shop integriert hat! 

Der Preis der Vollversion (Source) liegt bei 399,- € ein Update kostet 199,- €. Weitere Infos zum FDK:  auf meinem Blog
Download: HIER
Fragen einfach an: frank@delphiprofi.de

Die Geschichte des FDK


Seit Delphi XE2 besteht die Möglichkeit auch mobile Anwendungen (iOS) zu erzeugen, seit XE4 auch für Android. Schnell hat sich gezeigt, dass die App-Entwicklung mit Firemonkey nicht nur ein bisschen anders ist, sondern auch in vielen Teilen mit sehr viel Recherchen verbunden ist/war. Die offensichtliche Vorgehensweise war also hierfür EINE UNIT zu erzeugen und in diese Unit alles das rein zu packen, was für die mobile App-Entwicklung nötig war.

Da auf den mobilen Geräten immer alle Forms im Vollbildschirm angezeigt werden, musste erstmal eine Art Fenstermanager her. Auch stellt man unter Firemonkey schnell fest, dass die Style nur dann richtig funktionieren und das gilt besonders für Klick-Events, wenn man der UI-Task (Main-Thread) alle Zeit übriglässt, die verfügbar ist. Das bedeutet auch, dass man auf keinen Fall etwas in einen Button-Click-Event einfügen sollte das überhaupt Zeit kostet. Nachdem man also festgestellt hat, dass der User den Button gedrückt hat, muss so schnell wie möglich die Kontrolle wieder an den Main-Thread zurückgegeben werden. Aber wann kann ich dann meine Aktion die der Button auslösen sollte aufrufen? Die Antwort lautet: Entweder mache ich es in einem Thread oder ich warte darauf, dass die Applikation den OnIdle Event auslöst. Dies ist eigentlich schon die Magie der FMX-App-Entwicklung. Hierfür habe ich natürlich einen Entsprechenden Handler programmiert und diese Art des OnClick-Events zu behandeln.

Unzählige Units des FDK beschäftigen sich mit Threading, Erzeugen von Elementen zur Laufzeit, Interface-Wrapper damit man auch unter Windows alles testen kann, denn hier gibt es kein ARC, uvm.

Ein weiteres Thema ist sicherlich eine einfache Verwendung der SQLite Datenbank, die auf den mobilen Plattformen vorinstalliert ist. Die häufigste gestellte Frage ist: Wie bekomme ich meine Daten vom mobilen Gerät auf einen Server? Normalerweise sollte man hierfür einen REST-Service per JSON verwenden, also lag es nah, hierfür auch entsprechende Routinen zu programmieren.
Zahlreiche Funktionalitäten sind mittlerweile auch nativ in Delphi vorhanden, trotzdem sind meine Wrapper leichter zu bedienen. Bestes Beispiel ist sicherlich das Interface um auf der Android-Plattform die „neuen“ Berechtigungen abzufragen.

Der Firemonkey Neuling wird am Anfang sicherlich schnell auf Probleme stoßen, z.B. das die Bildschirmtastatur die Edit-Komponente überlagert. Auch hierfür gibt es im FDK einen Autoscroller.

Alle nötigen Einstellung, Datenbankverbindungen und Autoscroller sowie die Application-Events lassen sich mit einer Zeile erledigen.

Zur Zeit arbeite ich noch an einem MVVM-Plugin für das FDK sowie an einer Delphi-Tauglichen MVVM Stand-Alone Implementation.

Funktionen


Übersicht der Units in alphabetischer Reihenfolge. Alle Units haben den Namespace "Delphiprofi.FDK.*.pas". Units die mit (WIP) markiert sind, befinden sich zur Zeit noch in der Entwicklung. Sowie es die Zeit zuläßt, werde ich die Documentation mit dieser Liste verlinken. Meine Singleton sind alle Testbar, weil es jeweils eine BaseClass gibt die man selber instanzieren kann.
       
  • Amazon // Interface Wrapper für den Amazon-Cloud-Storage
  • AnyConverter // Generic Singleton für die Konvertierung von TypeA nach TypeB
  • AnyFactory // Singleton Factory - kann alles erzeugen - inkl. dependencies.
  • AppConfig // Meine Version eine INI-Datei in form einer SQLite-Datenbank
  • AppEventLogger // Datenbank basierter Logger der Events der App aufzeichnen kann.
  • AppGlobal // Singleton für die Behandlung von globalen Variablen
  • Async.Any // Generische worker Klasse um "jede" Verarbeitung Asyncron durchführen zu können.
  • Async.JSONStore // Thread/Queed JSON->REST Verarbeitung
  • Async // Worker, Controller, Async-Base Klasse
  • Attributes // Generic Singleton Handler. Hier können Klassentypen registriert werden und je Attribut eine Handler aufgerufen werden.
  • BackgroundWorker // Händer für Hintergrundverarbeitungen
  • Barcode // Interface-Wrapper für Barcode leser Android & IOS
  • Calendar // Eigene Kalender Implementation mit zahlreichen (beliebigen) skalierungen und markierfunktionen.
  • CallByIDFactory // Je nach ID (z.B. Plattform) wird dir "richtige" Methode aufgerufen.
  • Classes // Base-Klassen für Interfaces, Classen mit Thread-AutoSync und Interfaced-Debug Klassen.
  • Client.CRUD // Client Seite für ein CRUD Datenbank Interface
  • Client.JSONStore // Multi-Device, Multi-User, JSON-Datenbank mit autoupdate für alle Teilnehmer (Client Seite)
  • Compressing // Interface für alles was ge- und entpackt werden muss.
  • Compressing.ZLib // ZLib Implementation für Compressing
  • Config // Interface für Einstellung des FDK's und Logging
  • Console // Consolen Interface für Logger inkl. Farbausgabe
  • Converters // Vordefinierte Converter für den AnyConverter
  • Crypting.FMXLockBox // Interface für LockBox (GetIt)
  • Crypting // Interface für alles was verschlüsselt werden muss. Syncron und Asyncron.
  • DataStore // Threadsafe Warpper für Key-Value pairs und IDictionary implementation
  • DataView // Generic Interfaced Datenkontainer
  • DTOWithVersion // Simples Key-Value JSON Interface für Superobjects
  • Enumerables // Generic - Zahlreiche Erweiterungen für Enumerables und viele vordefinierte Typen
  • EventBus // Eventbus Implementation für Forder- und Hintergrund verarbeiten, MainThread Sync uvm.
  • Events // Application EventHandler
  • Exceptions.Handler // Application Exception Handler. Z.B. für Logging oder AppEventLogger
  • Exceptions // Eigene Exceptions und alle Exception-Texte des FDK
  • Factory // TDoubleDictionaryFactory
  • FireDAC.CRUD // CRUD Interface für FireDac
  • FireDAC.Driver // Windows / OSX Resourcen für SQLite / MySQL (MySQL - Res nicht enthalten)
  • FireDAC.ImportStream // Datenimportinterface um Daten von einer Desktop-App zu importieren.
  • FireDAC.Journal // Journal Erzeugen für SQLiteDatenbank I/O's
  • FireDAC.ORM // Meine ORM Implementation
  • FireDAC // FireDAC Wrapper - Keine Komponente auf den Forms benötigt.
  • FluentCreator // Generic Singleton für die Fluent erzeugen von Komponenten zur Laufzeit.
  • Fmx.Enumerables // Listed alle Komponenten eine FMX-Forms
  • FMXHelpers // Zahlreiche nützliche FMX Hilfen die keine eigene Unit gefunden haben.

  • Formatter (WIP) // Ein eigener Delphi SourceCode Formatter der ABSOLUT frei konfigurier bar ist.
    • Formatter.Composer // Registrierung von Behandlungsrutinen
    • Formatter.Config.Delphiprofi // Meine eignenen Formatter Einstellungen.
    • Formatter.Config // Globale Einstellungen
    • Formatter.Enumerables // Listen und Aufzählungen von z.B. registrieren Ausdrücken.
    • Formatter // Base Routinen
    • Formatter.Syntax // Syntax definitionen
    • Formatter.Tokenizer // Source-Tokeniter
    • Formatter.Types // InterfaceTypen und Classen

  • FTP // Interface Wrapper für IdFTP
  • Generics.BlockingCollections // Threadsafe Implementation für Datenlisten / Queue Verarbeitung
  • Generics.Collections // Generic Collection
  • HeartbeatWorker // Thread gesteuerte EventTrigger
  • Helpers // Allgemeine Hilfsroutinen die keinen Platz in einer eigenen Unit gefunden haben.
  • IdleWorker // Jeder FMX Entwickler braucht diesen Handler der eine Quene von Proceduren aufnehmen kann und diese Abarbeitet.
  • IFDEF // Einstellungen des FDK
  • IO // Interfaces (IDriveInfo, IFileSystemInfo, IFileInfo, IDirectoryInfo)
  • Json // JSON und REST Helper / Interfaces
  • JSONStore // Definition des JSONStore Records
  • Lang // Sprach Resourcen der Exceptions (de,fr,es,nl,ru,us) Googleübersetzer
  • Lists.Heap // IHeap sort
  • LocalWebModul // Debug Wrapper for lokale Webtests.

  • Logging
    • Logging.ConsoleLogger // Implementation für die Console
    • Logging.DebugLogger // Für die Ausgabe in die Debug-Console
    • Logging.FileLogger // Für die Ausgabe in eine Datei
    • Logging.LogFilter // Filter um Typen zu registrierten die nicht geloggt werden sollen.
    • Logging // Basis Implementation - THREADSAFE - Alle logging Ziele können gleichzeitig angesteuert werden.
    • Logging.ProcLogger // Logging informationen werden an eine Procedure weitergeleitet.
    • Logging.QueuedProcLogger // Threadsafe implementation die keine Zeit verbrucht auf der ausführenden Seite.
    • Logging.RemoteLogger // Loggingausgabe auf einen Remote-Server
    • Logging.SmartInspectLogger // Wrapper für Logausgabe an SmartInspect
    • Logging.TestInsightLogger // Logausgabe an die TestInsight Console (von Stefan Glienke)

  • MainApplication // Basis Implementation für Datenbank, AutoScroller uvm. (Z.B. Android Hardware Back Button)
  • Messages // Wrapper für System.Messages mit generischer Implementation und Interfacebasiertem unsubscribe.
  • MulticastEvents // Std. Multicast Events z.B. für MVVM
  • MulticastEvents.Types // Typen für Multicast Events
  • Neural // Einfaches neuronales Netzwerk
  • ObjectPool // Treadsafer generischer ObjectPool
  • Observer // Observer Interface und UISyncronizer Singelton.
  • Pattern.Internals // FDK Erweiterung des Singelton Patterns
  • Pattern // Generic Singelton Implementation. Jedes Class als Threadsafes Singelton verwenden.
  • Payment.Amazon (WIP) // Implementation für Amazon Payment - funktioniert noch nicht.
  • Payment.PayPal (WIP) // Implementation für PayPal Payment - funktioniert noch nicht.
  • Platform.Utils // Helper für die Plattform Services
  • Push // Interface Wrapper für Pushnotification
  • Queues // Interface Wrapper für: Threadsave Queues, generic CommandProcessor, Multithreading CommandProcessors, Ringspeicher
  • Registry.Installer // Registry Interface für den Installer-Eintrag in Windows.
  • Registry // FDK Registry Install-Helper.
  • Resource.compressed // Handler für gepackte Sprachresourcen
  • Resources // Handler für Sprachresourcen / Resourcenloader
  • REST // Interface für einen einfachen Zugang zu einem REST(full) Webserver
  • RTTI // Alles was für einen reibungslosen Zugang zur RTTI benötigt wird.
  • Security.Win // HTTPS Certificats Interface
  • Server.CRUD // Server Seite des CRUD Interfaces
  • Server.JSONStore // Server Seite des JSONStores
  • Server.SQLHelper // FluidCreator für SQL Statements (Basic)
  • Specifications // Basis Implementation
    • Specifications.Core // Generic Interface für die Spezifikationsverwaltung.
    • Specifications.Dates // Vordefinierte Spezifikation für das Datum
    • Specifications.Strings // Vordefinirte Spezifikation für Strings
  • Stateless // Generic StateMachine Implementation
  • Streams.Hashing // Stream Interface für die im Delphi enthaltenen Hash-Verfahren.
  • Streams.Internals // Interface PersistentStream
  • Streams // Basis Multitype Stream IO Implementation. Speichern, packen, hashen, verschlüsseln.
  • StringConsts // Basis für ResourceStrings
  • TCPConnection.IO // TCP/IP Handler
  • TCPConnection // TCP/IP Verbindungsimplementation
  • TCPConnection.SimpleTransfer // Einfaches Transferprotokoll
  • Tethering (WIP) // Interface Wrapper für App-Tethering
  • Tethering.Queue (WIP) // Wrapper für Datentransfer mit Warteschlange
  • Tethering.TransferObjects (WIP) // Transferiert Objecte
  • TextLayoutHelper // Blocksatz Textumbruch Helper

  • Threading
    • Threading.AsyncAwait // AnsyAwait Implementation
    • Threading.AsyncTasks // Async Task-Handler für Continuation
    • Threading // Helper für Threadsafe - Queue
    • Threading.Pipeline // Multi-Stage Pipeline Thread-Verwaltung (Eine der leistungsstärksten Thread Implemenationen im FDK)
    • Threading.Serializer // Threading Serializer - z.B. Für den Threadzugriff auf eine SQLite Datenbank
    • Threading.SimpleThread // Zahlreiche implementationen für einen einfache Threaderzeugung.
    • Threading.Timers // Thread gesteuerte Timer
    • TimeoutWorker // Thread für den zeitgesteuerten Aufruf von Methoden.

  • TreeViewWalker // Generische Klasse für einen einfachen Zugriff einen TreeView

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

  • Utils (Auszug)
    • TMethodRouter
    • TDelegateOnDestroy
    • TArray // Overload mit unzähligen Funktionen
    • TTree<T>
    • With // Continuation mit Argumenten
    • Sync // TMonitor Hilfsklasse
    • Switch<TResult>
    • Helper für Interlocked

  • Vcl.Enumerables // Listed alle Komponenten auf ein VCL Form.
  • WebLocal // Lokale Webserver implementation für debugging.
  • Winapi.Windows // Wrapper für Windows API Funktionen.
  • WindowManager // Handler für Form in Form Verwaltung (älter)

Kontakt Informationen


Netzwerke

Besuchen Sie und auf den diversen Plattformen.

Quick Contact

Email :


Infobase GmbH

Hostetstr. 153

52223 Stolberg (Rhld.)