Anzeigen: Delphi C++
Anzeigeeinstellungen

Mobile-Tutorial: Verwenden von FireDAC und SQLite (iOS und Android)

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)


Bevor Sie mit diesem Tutorial beginnen, sollten Sie das folgende Tutorial durcharbeiten:

In diesem Tutorial werden die grundlegenden Schritte zum Verwenden von SQLite als lokalen Datenspeicher auf Ihrem mobilen Gerät mit dem FireDAC-Framework beschrieben.

iOS Android

IOSScreen.png

AndroidScreen.png


Herstellen einer Verbindung zu der Datenbank mit FireDAC

FireDAC ist ein einzigartiger Satz von Universellen Datenzugriffs-Komponenten zur Entwicklung von plattformübergreifenden Datenbankanwendungen für Delphi und C++Builder. Durch seine leistungsstarke allgemeine Architektur ermöglicht FireDAC von Delphi aus einen nativen, extrem schnellen, direkten Zugriff auf InterBase, SQLite, MySQL, SQL Server, Oracle, PostgreSQL, IBM DB2, SQL Anywhere, Access, Firebird, Informix und weitere.

  • FireDAC unterstützt für die mobilen Plattformen InterBase ToGo sowie SQLite. Diese Datenbankprodukte können auf iOS- und Android-Geräten ausgeführt werden.
  • Für andere Datenbanken, wie z. B. Oracle, benötigen Sie zumindest eine Client-Bibliothek. Auf Windows-Plattformen wird die Client-Bibliothek für die Verbindung als DLL bereitgestellt. Deshalb müssen Sie Anwendungen mit Mittelschichttechnologien, wie DataSnap REST, entwickeln, um von mobilen Geräten eine Verbindung zu diesen Datenbankprodukten herzustellen.
Wie eine Verbindung zu einer Unternehmensdatenbank ohne eine Client-Bibliothek auf einem mobilen Gerät hergestellt wird, ist im Mobile-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken von einem mobilen Client aus (iOS und Android) beschrieben.

Erstellen der Datenbank mit dem FireDAC-Framework

Zuerst müssen Sie eine SQLite-Datenbankdatei auf Ihrer Windows-Entwicklungsplattform erstellen. Führen Sie die folgenden Schritte aus, um mit dem Formular-Designer die Benutzeroberfläche Ihrer mobilen App zu entwerfen.

Hinweis: Im Formular-Designer, aktivieren Sie die Master-Ansicht für dieses Tutorial.
  1. Wählen Sie zum Erstellen einer geräteübergreifenden Anwendung:
    • Für Delphi: Datei > Neu > Geräteübergreifende Anwendung - Delphi > Leere Anwendung
    • Für C++: Datei > Neu > Geräteübergreifende Anwendung - C++Builder > Leere Anwendung
  2. Doppelklicken Sie in der Tool-Palette auf die Komponente TFDConnection.
    FDConnectionComp.png
  3. Klicken Sie mit der rechten Maustaste auf die TFDConnection-Komponente, und wählen Sie Verbindungseditor.
  4. Legen Sie im FireDAC-Verbindungseditor die folgenden Parameter der TFDConnection-Komponente fest:
    • Setzen Sie die Eigenschaft Driver ID auf SQLite.
    • Setzen Sie den Parameter Database auf:
      C:\Users\Public\Documents\Embarcadero\Studio\19.0\Samples\Data\shoplist.s3db (Speicherort der Datenbank)
      und klicken Sie im Dialogfeld "Datei öffnen" auf Öffnen.
      Hinweis: Sie können den obigen Database-Parameter selbst dann festlegen, wenn shoplist.s3db nicht vorhanden ist. RAD Studio erstellt die Datenbank automatisch. (Damit die Datei Employees.s3db oder andere *.s3db-Dateien im Dialogfeld "Datei öffnen" angezeigt werden, wählen Sie die Option Alle Dateien (*.*).)
    • Setzen Sie den Parameter LockingMode auf normal.
      FDConnectionEditorSQLite.png

    • Klicken Sie auf die Schaltfläche Testen, um die Verbindung zu testen.
    • Klicken Sie auf OK, um den Verbindungseditor zu schließen.
  5. Legen Sie im Objektinspektor die folgenden Eigenschaften der TFDConnection-Komponente fest:
    • Setzen Sie die Eigenschaft LoginPrompt auf False, damit der Benutzer nicht zur Eingabe von Anmeldedaten aufgefordert wird.
    • Setzen Sie Eigenschaft Connected auf True.
  6. Doppelklicken Sie in der Tool-Palette auf die Komponente TFDQuery.
  7. Legen Sie im Objektinspektor die folgenden Eigenschaften der TFDQuery-Komponente fest:
    • Setzen Sie die Eigenschaft Name auf FDQueryCreateTable.
    • Geben Sie für die Eigenschaft "SQL" Folgendes ein:
      CREATE TABLE IF NOT EXISTS Item (ShopItem TEXT NOT NULL)
  8. Klicken Sie mit der rechten Maustaste auf die FDQueryCreateTable-Komponente, und wählen Sie Ausführen.

Entwerfen und Einrichten der Benutzeroberfläche

Sichtbare UI-Komponenten werden in den Designer geladen

In diesem Tutorial wird eine TListView-Komponente als UI-Element verwendet.

Führen Sie die folgenden Schritte aus, um eine ListView-Komponente und andere UI-Komponenten einzurichten:

  1. Ziehen Sie eine TToolBar-Komponente auf das Formular.
  2. Fügen Sie der ToolBar-Komponente eine TButton-Komponente hinzu, und legen Sie im Objektinspektor die folgenden Eigenschaften fest:
    • Setzen Sie die Eigenschaft Name auf ButtonAdd.
    • Setzen Sie die Eigenschaft StyleLookup auf addtoolbutton.
    • Legen Sie Alignauf Right fest.
  3. Fügen Sie der ToolBar-Komponente eine TButton-Komponente hinzu, und legen Sie im Objektinspektor die folgenden Eigenschaften fest:
    • Setzen Sie die Eigenschaft Name auf ButtonDelete.
    • Setzen Sie die Eigenschaft StyleLookup auf deletetoolbutton.
    • Legen Sie Align auf Left fest.
    • Setzen Sie Text auf Delete.
    • Setzen Sie die Eigenschaft Visible auf False.
  4. Fügen Sie der ToolBar-Komponente eine TLabel-Komponente hinzu, und legen Sie im Objektinspektor die folgenden Eigenschaften fest:
    • Setzen Sie Align auf Client.
    • Setzen Sie die Eigenschaft StyleLookup auf toollabel.
    • Setzen Sie die Eigenschaft Text auf Shopping List.
    • Erweitern Sie den Knoten TTextSettings, und setzen Sie die Eigenschaft HorzAlign auf Center.
  5. Ziehen Sie eine TListView-Komponente auf das Formular, und legen Sie im Objektinspektor die folgenden Eigenschaften fest:
    • Setzen Sie die Eigenschaft Align auf Client, damit sich die ListView-Komponente über das gesamte Formular erstreckt.

Verwenden des LiveBindings-Experten

In diesem Tutorial werden mit dem LiveBindings-Experten die LiveBindings-Komponenten (TBindSourceDB, TBindingsList) und die TFDQuery-Komponente hinzugefügt.

Hinzufügen der LiveBinding-Komponenten

  1. Wählen Sie Ansicht > LiveBindings-Designer. Der LiveBindings-Designer wird geöffnet.
  2. Wählen Sie LiveBindings-Experte.
    SelectLiveBindWizard.png

  3. Wählen Sie die Bindungsaufgabe Datenquelle erstellen aus.
  4. Klicken Sie auf die Schaltfläche Weiter.
  5. Wählen Sie den Klassennamen FireDAC.
  6. Klicken Sie auf die Schaltfläche Weiter.
  7. Ändern Sie den Befehlstyp in Abfrage.
  8. Legen Sie die Eigenschaft Befehlstext auf select ShopItem from Item fest.
    LiveBindWizardFDSQLite.png

  9. Klicken Sie auf die Schaltfläche Befehl testen.
  10. Klicken Sie auf die Schaltfläche Weiter.
  11. Klicken Sie auf die Schaltfläche Fertig stellen.

Damit wurden dem Formular die Komponenten TBindSourceDB und TFDQuery hinzugefügt.

Herstellen einer Verbindung zu den Daten

  1. Öffnen Sie den LiveBindings-Experte|LiveBindings-Experten erneut.
  2. Wählen Sie die Bindungsaufgabe Steuerelement mit einem Feld verknüpfen aus.
    ControlFieldWizard.png

  3. Klicken Sie auf die Schaltfläche Weiter.
  4. Aktivieren Sie die Registerkarte Vorhandenes Steuerelement.
  5. Wählen Sie die Komponente ListView1 aus.
  6. Klicken Sie auf die Schaltfläche Weiter.
  7. Wählen Sie BindSourceDB1 aus.
  8. Klicken Sie auf die Schaltfläche Weiter.
  9. Wählen Sie den Feldnamen ShopItem aus.
    FieldNameWizardSQLite.png

  10. Klicken Sie auf die Schaltfläche Weiter.
  11. Klicken Sie auf die Schaltfläche Fertig stellen, um den Experten zu schließen.

Hinweis: Diese letzten Schritte sind für dieses Tutorial nicht obligatorisch , weil es in BindSourceDB1 nur ein Feld gibt. Diese Schritte sind aber bei der Verwaltung mehrerer Felder einer Datenbank hilfreich.

Anzeigen von ShopItem in der ListView-Komponente

Mit dem folgendem Schritt wird der Text von ShopItem in der TListView-Komponente angezeigt.

  1. Wählen Sie im LiveBindings-Designer das Element ShopItem in der BindSourceDB1-Komponente aus, und ziehen Sie ShopItem auf Item.Text in ListView1.
    LiveBindings-Designer

Durch diese Schritte wird die Benutzeroberfläche der App mit den Daten in der SQLite-Datenbank verbunden. Wenn Sie für dieses Tutorial eine Tabelle mit Daten verwendet haben, werden die Daten jetzt im Formular-Designer angezeigt.

Erstellen einer Ereignisbehandlungsroutine zur Anzeige der Schaltfläche "Delete" bei Auswahl eines Eintrags aus der Liste durch den Benutzer

Die Eigenschaft Visible der Schaltfläche Delete wird auf False gesetzt. Deshalb ist diese Schaltfläche für den Benutzer standardmäßig nicht sichtbar. Sie können die Schaltfläche folgendermaßen anzeigen, wenn der Benutzer einen Eintrag in der Liste auswählt:

  • Wählen Sie ListView1 aus, und definieren Sie die folgende Ereignisbehandlungsroutine für das Ereignis OnItemClick.
Delphi:
procedure TForm1.ListView1ItemClick(const Sender: TObject;
  const AItem: TListViewItem);
begin
  ButtonDelete.Visible := ListView1.Selected <> nil;
end;
  • Für C++:
void __fastcall TForm1::ListView1ItemClick(const TObject *Sender,
    const TListViewItem *AItem) {
    ButtonDelete->Visible = (ListView1->Selected != NULL);
}

Erstellen einer Ereignisbehandlungsroutine für die Schaltfläche "Add" zum Hinzufügen eines Eintrags zu der Liste

Datenbankverbindungen werden ebenfalls konfiguriert

Im nächsten Schritt wird diese Anwendung durch eine Funktion zum Hinzufügen von Einträgen zu der Einkaufsliste erweitert.

  1. Ziehen Sie eine TFDQuery-Komponente auf das Formular.
  2. Legen Sie im Objektinspektor die folgenden Eigenschaften fest:
    • Setzen Sie die Eigenschaft Name auf FDQueryInsert.
    • Geben Sie für die Eigenschaft "SQL" Folgendes ein:
      INSERT INTO ITEM (ShopItem) VALUES (:ShopItem)
    • Klicken Sie in der Eigenschaft Params auf die Erweitern-Schaltfläche (...).
    • Wählen Sie den Parameter ShopItem aus, und setzen Sie DataType auf ftString:
      EditingShopItemParameterSQLite.png

  3. Klicken Sie in der Strukturansicht mit der rechten Maustaste auf die ButtonAdd-Komponente, und wählen Sie Element > Nach vorne setzen. Dadurch wird die Schaltfläche in den Vordergrund des aktiven Formulars gesetzt.
  • Für Delphi:
  • Deklarieren Sie im private-Abschnitt die folgende Prozedur:
private
  procedure OnInputQuery_Close(const AResult: TModalResult; const AValues: array of string);
  • Fügen Sie die folgende Prozedur hinzu :
procedure TForm1.OnInputQuery_Close(const AResult: TModalResult; const AValues: array of string);
var
  TaskName: String;
begin
 TaskName := string.Empty;
  if AResult <> mrOk then
    Exit;
  TaskName := AValues[0];
  try
    if (TaskName.Trim <> '')
    then
    begin
      FDQueryInsert.ParamByName('ShopItem').AsString := TaskName;
      FDQueryInsert.ExecSQL();
      FDQuery1.Close();
      FDQuery1.Open;
      ButtonDelete.Visible := ListView1.Selected <> nil;
    end;
  except
    on e: Exception do
    begin
      ShowMessage(e.Message);
    end;
  end;
end;
  • Doppelklicken Sie im Formular-Designer auf die Komponente ButtonAdd. Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine hinzu:
procedure TForm1.ButtonAddClick(Sender: TObject);
begin
  TDialogServiceAsync.InputQuery('Enter New Item', ['Name'], [''], Self.OnInputQuery_Close)
end;
  • Für C++:

Um dieselbe Funktionalität in C++ zu erhalten, sind zusätzliche Schritte erforderlich.

  • Fügen Sie nach der TForm1-Definition die folgende Definition hinzu (in der .h-Datei Ihrer Unit):
typedef void __fastcall(__closure * TInputCloseQueryProcEvent)
    (const System::Uitypes::TModalResult AResult,
    System::UnicodeString const *AValues, const int AValues_High);
  • Fügen Sie die folgende Klassendefinition hinzu (in der .h-Datei Ihrer Unit nach dem zuvor definierten Typ):
class InputQueryMethod : public TCppInterfacedObject<TInputCloseQueryProc>
{
private:
    TInputCloseQueryProcEvent Event;
 
public:
    InputQueryMethod(TInputCloseQueryProcEvent _Event) {
        Event = _Event;
    }
 
    void __fastcall Invoke(const System::Uitypes::TModalResult AResult,
        System::UnicodeString const *AValues, const int AValues_High) {
        Event(AResult, AValues, AValues_High);
    }
};
  • Fügen Sie in den private-Abschnitt des Formulars die folgende Deklaration ein (in der .h-Datei Ihrer Unit):
private: //User declarations
    void __fastcall OnInputQuery_Close
        (const System::Uitypes::TModalResult AResult,
        System::UnicodeString const *AValues, const int AValues_High);
  • Fügen Sie folgenden Code hinzu (in der .cpp-Datei Ihrer Unit):
void __fastcall TForm1::OnInputQuery_Close(const System::Uitypes::TModalResult AResult,
        System::UnicodeString const *AValues, const int AValues_High) {
    String TaskName;
    TaskName = "";
    if (AResult != mrOk)
        return;
    TaskName = AValues[0];
try {
        if  (!(Trim(TaskName) == "")) {
            FDQueryInsert->ParamByName("ShopItem")->AsString = TaskName;
            FDQueryInsert->ExecSQL();
            FDQuery1->Close();
            FDQuery1->Open();
            ButtonDelete->Visible = (ListView1->Selected != NULL);
        }
    }
    catch (Exception &e) {
        ShowMessage(e.Message);
    }
}
  • Doppelklicken Sie im Formular-Designer auf die Komponente ButtonAdd. Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine hinzu:
void __fastcall TForm1::ButtonAddClick(TObject *Sender) {
    String caption = "Enter New Item";
    String Prompts[1];
    Prompts[0] = "Name:";
    String Defaults[1];
    Defaults[0] = "";
    _di_TInputCloseQueryProc Met = new InputQueryMethod(&OnInputQuery_Close);
    TDialogServiceAsync::InputQuery(
        caption, Prompts, 0, Defaults, 0, (TInputCloseQueryProc *)Met);
}

Die Funktion InputQuery zeigt ein Dialogfeld an, in dem der Benutzer aufgefordert wird, Text einzugeben. Diese Funktion gibt True zurück, wenn der Benutzer auf OK klickt, damit der Datenbank nur dann Daten hinzugefügt werden, wenn der Benutzer OK wählt, und der Text nicht leer ist.

iOS Android

UsingInputQueryOniOS.PNG

EnterItemAndroid.png

Erstellen einer Ereignisbehandlungsroutine für die Schaltfläche "Delete" zum Entfernen eines Eintrags aus der Liste

Im nächsten Schritt wird diese Anwendung um eine Funktion zum Entfernen von Einträgen aus der Einkaufsliste erweitert:

  1. Ziehen Sie eine TFDQuery-Komponente auf das Formular.
  2. Legen Sie im Objektinspektor die folgenden Eigenschaften fest:
    • Setzen Sie die Eigenschaft Name auf FDQueryDelete.
    • Geben Sie für die Eigenschaft "SQL" Folgendes ein:
      delete from Item where ShopItem = :ShopItem
    • Klicken Sie in der Eigenschaft Params auf die Erweitern-Schaltfläche (...).
    • Wählen Sie den Parameter ShopItem aus, und setzen Sie DataType auf ftString.
  3. Klicken Sie in der Strukturansicht mit rechten Maustaste auf die ButtonDelete-Komponente, und wählen Sie Steuerelement > Nach vorne setzen. Dadurch wird die Schaltfläche in den Vordergrund eines aktiven Formulars gesetzt.
  4. Doppelklicken Sie im Formular-Designer auf die Komponente ButtonDelete. Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine hinzu.
  • Für Delphi:
procedure TForm1.ButtonDeleteClick(Sender: TObject);
var
  TaskName: String;
begin
  TaskName := TListViewItem(ListView1.Selected).Text;
 
  try
    FDQueryDelete.ParamByName('ShopItem').AsString := TaskName;
    FDQueryDelete.ExecSQL();
    FDQuery1.Close;
    FDQuery1.Open;
    ButtonDelete.Visible := ListView1.Selected <> nil;
  except
    on e: Exception do
    begin
      SHowMessage(e.Message);
    end;
  end;
end;
  • Für C++:
void __fastcall TForm1::ButtonDeleteClick(TObject *Sender) {
    String TaskName = ((TListViewItem*)(ListView1->Selected))->Text;
    try {
        FDQueryDelete->ParamByName("ShopItem")->AsString = TaskName;
        FDQueryDelete->ExecSQL();
        FDQuery1->Close();
        FDQuery1->Open();
        ButtonDelete->Visible = (ListView1->Selected != NULL);
    }
    catch (Exception &e) {
        ShowMessage(e.Message);
    }
}

Vorbereiten der Anwendung für die Ausführung

FireDAC verfügt über eine lose verbundene mehrschichtige Architektur, in der Dienste von Schichten bereitgestellt werden. Eine Dienst-API ist als COM-Interface definiert, das von anderen Schichten über den Interface-Generator angefordert werden kann.

Für die ordnungsgemäße Ausführung von FireDAC müssen Sie die Implementierung der Interfaces IFDGUIxWaitCursor und IFDPhysDriver in Ihre Anwendung einbinden.

Ziehen Sie hierzu die Komponenten TFDGUIxWaitCursor und TFDPhysSQLiteDriverLink auf das Formular.

Einrichten der Datenbankbereitstellung für mobile Geräte

Bis jetzt haben Sie SQLite auf dem Desktop verwendet. Das bedeutet, dass sich die eigentliche Datenbank auf Ihrer lokalen Festplatte (z. B. C:\Users\Public\Documents\Embarcadero\Studio\19.0\Samples\Data\shoplist.s3db) befindet. Auf mobilen Geräten befinden sich Anwendungen in einer Sandbox, und in der Regel können Sie Daten nur lesen und schreiben, die sich im Ordner Documents (iOS-Geräte) oder im internal Speicher (Android-Geräte) unter dem Anwendungsordner befinden.

Führen Sie die folgenden Schritte aus, um eine Verbindung zu einer lokalen Datenbank auf mobilen Geräten herzustellen:

  • Stellen Sie die Datenbank auf dem mobilen Gerät bereit.
  • Ändern Sie die Konfiguration (für die Verbindung mit der Datenbankdatei) im Ordner Documents (für iOS-Geräte) oder im internen Speicher (für Android-Geräte).

Hinzufügen und Konfigurieren der Datenbankdatei im Bereitstellungs-Manager

Bevor Sie Ihre Anwendung auf einem mobilen Gerät ausführen können, müssen Sie die Bereitstellung für Ihre Datenbankdatei (shoplist.s3db) einrichten.

  1. Sie können die Datenbank mit einer der beiden folgenden Methoden dem Projekt hinzufügen:
    • Klicken Sie in der Projektverwaltung mit der rechten Maustaste auf den Projektnamen, und wählen Sie im Kontextmenü Hinzufügen… (oder Projekt > Dem Projekt hinzufügen) aus, um das Dialogfeld Dem Projekt hinzufügen anzuzeigen. Navigieren Sie zum Speicherort der Datenbank C:\Users\Public\Documents\Embarcadero\Studio\19.0\Samples\Data, wählen Sie die Datenbank shoplist.s3db aus, und klicken Sie auf Öffnen.
    • Navigieren Sie zum Speicherort der Datenbank C:\Users\Public\Documents\Embarcadero\Studio\19.0\Samples\Data, und ziehen Sie in der Projektverwaltung die Datenbank shoplist.s3db auf das Projekt. Klicken Sie auf Ja, um zu bestätigen, dass Sie die Datei dem Projekt hinzufügen möchten.
  2. Nachdem die Datenbankdatei hinzugefügt wurde, wird das Fenster Weitere Dateien angezeigt. Klicken Sie auf Abbrechen, um es zu schließen.
  3. Öffnen Sie den Bereitstellungs-Manager mit Projekt > Bereitstellung.
  4. Wählen Sie oben im Bereitstellungs-Manager in der Dropdown-Liste mit den Zielplattformen Debug-Konfiguration - iOS-Geräteplattform - 32-Bit-Plattform, Debug-Konfiguration - iOS-Geräteplattform - 64-Bit-Plattform oder Debug-Konfiguration - Android-Plattform aus, und überzeugen Sie sich davon, dass die Datenbank shoplist.s3db den Plattformen hinzugefügt wurde.
  5. Der Remote-Pfad von shoplist.s3db wurde für die iOS- und Android-Plattformen wie folgt festgelegt:
    • Remote-Pfad auf der iOS-Geräteplattform: StartUp\Documents\
    RemotePathiOS.png

    • Remote-Pfad auf der Android-Plattform: assets\internal\
    RemotePathAndroid.png

Damit haben Sie festgelegt, dass beim Ausführen Ihrer App auf dem mobilen Gerät die Datenbankdatei (shoplist.s3db) im Ordner Documents (iOS-Plattform) oder im internen Speicher (Android-Plattform) im Sandbox-Bereich Ihrer geräteübergreifenden Anwendung bereitgestellt wird.

Ändern des Codes für die Verbindung zu einer lokalen Datenbankdatei auf mobilen Geräten

Die Hauptfunktionen für diese Anwendung sind nun implementiert. Anhand der Schritte in diesem Tutorial haben Sie eine Datenbankdatei unter Windows erstellt. Die Datenbankdatei steht erst für Ihr mobiles Gerät zur Verfügung, wenn Sie sie auf das mobile Gerät kopieren oder ad-hoc erstellen.

Mit den folgenden Schritten können Sie eine SQLite-Datenbank und -Tabelle erstellen:

Festlegen des Speicherorts der SQLite-Datenbank auf dem mobilen Gerät

  1. Wählen Sie im Formular-Designer die FDConnection1-Komponente aus.
  2. Doppelklicken Sie im Objektinspektor auf das Ereignis BeforeConnect.
  3. Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine hinzu:
  • Für Delphi:
procedure TForm1.FDConnection1BeforeConnect(Sender: TObject);
begin
  {$IF DEFINED(iOS) or DEFINED(ANDROID)}
  FDConnection1.Params.Values['Database'] :=
      TPath.Combine(TPath.GetDocumentsPath, 'shoplist.s3db');
  {$ENDIF}
end;

Der Record TPath wird in der Unit System.IOUtils deklariert, daher müssen Sie System.IOUtils in die uses-Klausel der Unit aufnehmen.

implementation
 
{$R *.fmx}
uses  System.IOUtils;
  • Für C++:
void __fastcall TForm1::FDConnection1BeforeConnect(TObject *Sender) {
#if defined(_PLAT_IOS) || defined(_PLAT_ANDROID)
    FDConnection1->Params->Values["Database"] =
        System::Ioutils::TPath::Combine(System::Ioutils::TPath::GetDocumentsPath
        (), "shoplist.s3db");
#endif
}

Sie müssen #include <System.IOUtils.hpp> hinzufügen.

Erstellen einer Tabelle, falls keine vorhanden ist

Mit SQLite können Sie mit der Anweisung CREATE TABLE IF NOT EXISTS eine Tabelle erstellen, wenn noch keine Tabelle vorhanden ist. Eine Tabelle sollte angelegt werden, nachdem die TFDConnection-Komponente eine Verbindung zu der Datenbank hergestellt hat und bevor die TFDQuery-Komponente eine Verbindung zu der Tabelle herstellt. Gehen Sie dazu folgendermaßen vor:

  1. Wählen Sie im Formular-Designer die FDConnection1-Komponente aus.
  2. Doppelklicken Sie im Objektinspektor auf das Ereignis AfterConnect.
  3. Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine hinzu:
  • Für Delphi:
procedure TForm1.FDConnection1AfterConnect(Sender: TObject);
begin
  FDConnection1.ExecSQL('CREATE TABLE IF NOT EXISTS Item (ShopItem  TEXT NOT NULL)');
end;
  • Für C++:
void __fastcall TForm1::FDConnection1AfterConnect(TObject *Sender) {
    FDConnection1->ExecSQL("CREATE TABLE IF NOT EXISTS Item (ShopItem  TEXT NOT NULL)");
}

Ausführen der Anwendung auf einem Simulator oder auf einem mobilen Gerät

Ihre Anwendung kann jetzt auf einem Simulator oder einem angeschlossenen mobilen Gerät ausgeführt werden.
So führen Sie die Anwendung aus:

  1. Wählen Sie in der Projektverwaltung die Zielplattform aus.
    Targets.png
  2. Wählen Sie einen der folgenden Befehle aus:
    • Start > Start
    • Start > Ohne Debugger ausführen
iOS Android

IOSScreen.png

AndroidScreen.png


Hinweis: Falls bei der Ausführung der Anwendung Probleme auftreten, befolgen Sie die Schritte unter Fehlerbehebung.

Siehe auch

RAD Studio 10.2 Tokyo
In anderen Sprachen
Frühere Versionen
Assistenz