Android procedure auf ShowModal warten

[Sir Rufo]

Zitat von bra:

Application.Processmessages ist eine ganz schlechte Idee unter Android/iOS...

Wieso das denn?

Dieses Application.ProcessMessages beim ShowModal ist extra für die Mobile Plattformen herausgenommen worden. Da hat sich doch bestimmt keiner etwas bei gedacht. Das ist nur um alle zu ärgern.

[NickD]

Ich habe gerade das Gefühl in dieser Situation gibt es kein "Richtig", kann das sein?
@SirRufo: Würde mich über ein bisschen Quellcode bezogen auf mein Beispiel freuen, so ganz komme ich mit den Callbacks nicht klar


@Mavarik: Wenn ich es so versuche hängt sich die komplette App auf..

[bra]

Zitat von Sir Rufo:

Zitat von bra:

Application.Processmessages ist eine ganz schlechte Idee unter Android/iOS...

Wieso das denn?

Dieses Application.ProcessMessages beim ShowModal ist extra für die Mobile Plattformen herausgenommen worden. Da hat sich doch bestimmt keiner etwas bei gedacht. Das ist nur um alle zu ärgern.

Keine Ahnung, ob das jetzt ironisch gemeint war oder ich es einfach nicht verstehe...

In unserer App haben die Application.ProcessMessages jedenfalls zu massiven Problemen geführt (besonders im Zusammenhang mit Threads). Inzwischen haben wir alle bis auf eine Stelle eliminieren können und seitdem damit keine Probleme mehr. Ist ja nicht so, dass es sonst nicht schon genug Stolpersteine gäbe ^^

[jaenicke]

Um zur Ausgangsfrage zurückzukehren:
Man macht das so, dass man auf die Events des zweiten Formulars reagiert und gar nicht wartet.

Sprich der Ablauf ist so:

• Zeige zweites Formular an (normales Show)
• Im zweiten Formular löse ein Event aus, wenn z.B. eine Farbe ausgewählt wurde
• Im ersten Formular reagiere auf die Änderung der Farbe, z.B. indem etwas neu gezeichnet werden muss
• Wenn das zweite Formular geschlossen wird, wird wieder das erste Fenster aktiv

Dann muss niemand irgendwo warten.

[greenmile]

Da macht es ja vielleicht Sinn. Aber was ist mit einer Messagebox wie "Möchten Sie beenden"? Extra Callback für jede erdenkliche Messagebox, Inputquery und co ist doch wirklich Overkill, oder?

[jaenicke]

Dafür aber sauber...

Und wenn man von Anfang an so denkt, ist das auch überhaupt kein Problem...

Problematisch ist nur die Umstellung von altem Code.

[bra]

Zitat von greenmile:

Da macht es ja vielleicht Sinn. Aber was ist mit einer Messagebox wie "Möchten Sie beenden"? Extra Callback für jede erdenkliche Messagebox, Inputquery und co ist doch wirklich Overkill, oder?

Für MessageBoxes kann man doch eine anonyme Procedure übergeben, wo man die Ereignisbehandlung macht.

[bra]

Wir haben uns eine eigene Unit für Standard-MessageBoxes erstellt, läuft mit Windows, iOS und Android:

Code:

unit uMessageDialogs;

interface

uses
  System.UITypes, System.SysUtils, System.Types, System.Generics.Defaults,
  FMX.Dialogs;

type
  TDialogButtons = (dbOk, dbOkCancel, dbYesNo);

  TMessageDialogs = class
  private
    class procedure PlatformDialog(const AMessage: String; const ADialogType: TMsgDlgType; const ADialogButtons: TDialogButtons; const AProcedure: TInputCloseDialogProc);
  public
    class procedure Info(const AMessage: String);
    class procedure Warn(const AMessage: String);
    class procedure Error(const AMessage: String);
    class procedure ConfirmYesNo(const AMessage: String; const ADialogType: TMsgDlgType; const AProcedureOnYes: TProc; const AProcedureOnNo: TProc = nil);
    class procedure ConfirmOkCancel(const AMessage: String; const ADialogType: TMsgDlgType; const AProcedureOnOk: TProc; const AProcedureOnCancel: TProc = nil);
    class procedure Custom(const AMessage: String; const ADialogType: TMsgDlgType; const ADialogButtons: TDialogButtons; const AProcedure: TInputCloseDialogProc);
  end;

implementation

uses
{$IFDEF MSWINDOWS}
  Windows, FMX.Platform.Win,
{$ENDIF}
  fRISApp, uFormSupport, uSupport, uConsts;

class procedure TMessageDialogs.PlatformDialog(const AMessage: String; const ADialogType: TMsgDlgType; const ADialogButtons: TDialogButtons; const AProcedure: TInputCloseDialogProc);
{$IFDEF MSWINDOWS}
var
  uType: Cardinal;
  caption: String;
  res: Integer;
begin
  // Dialoge werden sonst unter Windows nicht Modal angezeigt, lassen sich also in den Hintergrund legen

  uType := MB_OK;
  case ADialogButtons of
    dbOk:       uType := MB_OK;
    dbOkCancel: uType := MB_OKCANCEL;
    dbYesNo:    uType := MB_YESNO;
  end;
  uType := uType or MB_TASKMODAL;

  case ADialogType of
    TMsgDlgType.mtWarning:
      begin
        caption := 'Warnung';
        uType := uType or MB_ICONWARNING;
      end;
    TMsgDlgType.mtError:
      begin
        caption := 'Fehler';
        uType := uType or MB_ICONERROR;
      end;
    TMsgDlgType.mtInformation:
      begin
        caption := 'Information';
        uType := uType or MB_ICONINFORMATION;
      end;
    TMsgDlgType.mtConfirmation:
      begin
        caption := 'Bestätigung';
        uType := uType or MB_ICONQUESTION;
      end;
    else
      Assert(True);
  end;

  if GetMainForm = nil then
    res := Windows.MessageBox(0, PWideChar(AMessage), PWideChar(caption), uType)
  else
    res := Windows.MessageBox(FMX.Platform.Win.WindowHandleToPlatform(GetMainForm.Handle).Wnd, PWideChar(AMessage), PWideChar(caption), uType);
  if Assigned(AProcedure) then
    AProcedure(res);
end;
{$ELSE}
var
  dlgButtons: TMsgDlgButtons;
begin
  case ADialogButtons of
    dbOk:       dlgButtons := [TMsgDlgBtn.mbOK];
    dbOkCancel: dlgButtons := [TMsgDlgBtn.mbOK, TMsgDlgBtn.mbCancel];
    dbYesNo:    dlgButtons := [TMsgDlgBtn.mbYes, TMsgDlgBtn.mbNo];
  end;
  FMX.Dialogs.MessageDlg(AMessage, ADialogType, dlgButtons, 0, AProcedure);
end;
{$ENDIF}

class procedure TMessageDialogs.Info(const AMessage: String);
begin
  PlatformDialog(AMessage, TMsgDlgType.mtInformation, dbOk, nil);
end;

class procedure TMessageDialogs.Warn(const AMessage: String);
begin
  PlatformDialog(AMessage, TMsgDlgType.mtWarning, dbOk, nil);
end;

class procedure TMessageDialogs.Error(const AMessage: String);
begin
  PlatformDialog(AMessage, TMsgDlgType.mtError, dbOk, nil);
end;

class procedure TMessageDialogs.Custom(const AMessage: String; const ADialogType: TMsgDlgType; const ADialogButtons: TDialogButtons; const AProcedure: TInputCloseDialogProc);
begin
  PlatformDialog(AMessage, ADialogType, ADialogButtons, AProcedure);
end;

class procedure TMessageDialogs.ConfirmOkCancel(const AMessage: String; const ADialogType: TMsgDlgType; const AProcedureOnOk, AProcedureOnCancel: TProc);
begin
  PlatformDialog(AMessage, ADialogType, dbOkCancel,
    procedure(const AResult: TModalResult)
    begin
      if GetMainForm <> nil then
        GetMainForm.Status(Format('Dialog-Result: %d, Dialog: %s', [AResult, AMessage]), TStatusType.stDebug);
      if AResult = mrOK then begin
        if Assigned(AProcedureOnOK) then
          AProcedureOnOK;
      end
      // Alternativ-Prozedur wird immer ausgeführt, wenn vorhanden.
      // Damit wird ein Problem unter Android behoben, wo sich Dialoge durch Klicken außerhalb abbrechen lassen
      else if Assigned(AProcedureOnCancel) then
        AProcedureOnCancel;
    end
  );
end;

class procedure TMessageDialogs.ConfirmYesNo(const AMessage: String; const ADialogType: TMsgDlgType; const AProcedureOnYes: TProc; const AProcedureOnNo: TProc);
begin
  PlatformDialog(AMessage, ADialogType, dbYesNo,
    procedure(const AResult: TModalResult)
    begin
      if GetMainForm <> nil then
        GetMainForm.Status(Format('Dialog-Result: %d, Dialog: %s', [AResult, AMessage]), TStatusType.stDebug);
      if AResult = mrYes then begin
        if Assigned(AProcedureOnYes) then
          AProcedureOnYes;
      end
      // Alternativ-Prozedur wird immer ausgeführt, wenn vorhanden
      // Damit wird ein Problem unter Android behoben, wo sich Dialoge durch Klicken außerhalb abbrechen lassen
      else if Assigned(AProcedureOnNo) then
        AProcedureOnNo;
    end
  );
end;

end.

[NickD]

Zitat von jaenicke:

Um zur Ausgangsfrage zurückzukehren:
Man macht das so, dass man auf die Events des zweiten Formulars reagiert und gar nicht wartet.

Sprich der Ablauf ist so:

• Zeige zweites Formular an (normales Show)
• Im zweiten Formular löse ein Event aus, wenn z.B. eine Farbe ausgewählt wurde
• Im ersten Formular reagiere auf die Änderung der Farbe, z.B. indem etwas neu gezeichnet werden muss
• Wenn das zweite Formular geschlossen wird, wird wieder das erste Fenster aktiv

Dann muss niemand irgendwo warten.

So würde man natürlich vorgehen. Geht man aber mal davon aus, das ein neues Formular in einer Prozedur angezeigt werden muss und nach der Benutzereingabe diese Prozedur fotgesetzt werden muss, gibt es keine Lösung in der mobilen Entwicklung. Habe ich das richtig verstanden?

[jaenicke]

Keine gute, weil das unter Android nicht so gemacht werden soll.

Und warum sollte auch eine Prozedur fortgesetzt werden? Du brauchst den Code nach dem Aufruf des Fensters doch nur in das Event zu schreiben, dass das zweite Fenster bestätigt oder abgebrochen wurde.