SMS automatisch Empfangen

[ManfredU]

Ich suche eine Lösung mit Delphi 12.1 CE eine Android App zu schreiben dass mir, wenn eine SMS einlangt, den Text der SMS automatisch ausliest und darauf verschiedene Aktionen setzt. Dies soll auch dann funktionieren, wenn die App im Hintergrund ist oder auch wenn das Handy im Standby ist. Eine SMS auslesen, funktioniert bereits, jedoch nur nach händischer Aktion.
Ich suche bereits vergebens, habe aber noch nichts passendes gefunden.
Vielleicht hat jemand einen Vorschlag wie das in Delphi funktioniert.
Ich habe vor einigen Jahren in Android Studio so ein Programm geschrieben, das bis heute perfekt funktioniert. Ich möchte dieses jetzt aber durch ein Delphi App ersetzen. Damals verwendete ich einen Broadcast Receiver. Darüber finde ich in Delphi aber nichts.
Danke und LG

[zeras]

Ich hatte mir einmal den Link gespeichert und zur Vorsorge in mein Projekt eingebaut. Habe es aber nie probiert, da ich ein Tablett für meine App nutze.
Vielleicht hilft es ja trotzdem.
Hier der Link. Ist zwar offenbar mit einer älteren Delphi Version getestet worden. Da es aber die Berechtigungen für SMS lesen und schreiben noch gibt, wird es dann wohl eine Möglichkeit geben.

[ManfredU]

Hallo zeras!
Danke für die Antwort, aber diese Funktion habe ich eh schon gefunden, die liest nur nach händischer Aktion eine SMS aus. Funktioniert aber nicht automatisch im Hintergrund.
LG

[Olli73]

So weit ich weiß musst du dazu was im Manifest eintragen und dann im Programm darauf reagieren.

Diese Komponente könnte dir aber Arbeit abnehmen. Dort ist sogar SMS als Beispiel direkt aufgeführt.

https://nilcemar.medium.com/handle-b...t-53329ca7dd58

[Rollo62]

Zitat von ManfredU:

Ich habe vor einigen Jahren in Android Studio so ein Programm geschrieben, das bis heute perfekt funktioniert.

Dann würde ich ehrlich gesagt erstmal dabei bleiben. Delphi kann viele spezielle Dinge wie SMS oder Hintergrundausführung, nicht ganz so perfekt, da ist die Chance bei Android eine Lösung out-of-the-box zu finden wesentlich größer.

Ansonsten könntest Du auch bei bei Kastri vorbeischauen, wo es eine ganze Menge aktuelle Fixes für solche speziellen Dinge gibt, das ist immer sehr aktuell.
https://github.com/DelphiWorlds/Kast...tReceiver.java
Das ist aber immer ein Wettlauf mit neuen Android-Änderungen.

[ManfredU]

Danke für eure Antworten und Anregungen. Ich habe nilcemar und Barisatalay (kastri hat nur händisches einlesen einer SMS) ausprobiert. Beide haben eine Broadcast Komponente die ich installiert habe und dann lt. Demos ausprobiert (leider nicht mit receive_SMS). Es geht bei beiden mein Projekt am Android 13 Tablet ausführen, broadcast registrieren und dann senden, jedoch wenn ich von meinem Handy ein SMS an das Tablet schicke kommt das SMS mit einer Nachricht zwar an, aber mein APP rührt sich nicht, auch nicht im OnReceive der Komponente.
Ich probiere und suche im Internet schon seit Tagen, und es will einfach nicht funktionieren. Vielleicht weiß jemand wo mein Fehler liegt, oder hat schon so eine App die funktioniert. Ich wäre froh über ein Stück funktionierendem Delphi Code.
Anbei ein paar Ausschnitte meines Programmes.

AndroidStudio habe ich auch die neueste Version installiert, jedoch die verwenden jetzt Kotlin statt JAVA. Diese Sprache kann ich gar nicht und JAVA auch nur am Rande, daher wollte ich es in Delphi programmieren.

Danke und LG



Diese Berechtigungen in der Manifest und im Delphi Code habe ich alle schon ausprobiert

<uses-permission android:name="android.permission.DELIVER_COMPANION _MESSAGES" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.READ_SMS" />
<uses-permission android:name="android.permission.RECEIVE_SMS" />
<uses-permission android:name="android.permission.REQUEST_COMPANION _RUN_IN_BACKGROUND" />
<uses-permission android:name="android.permission.REQUEST_COMPANION _USE_DATA_IN_BACKGROUND" />
<uses-permission android:name="android.permission.SEND_SMS" />


Und diese Einträge in der Manifest habe ich auch schon einzeln ausprobiert.
<receiver android:name="com.embarcadero.rtl.notifications.No tificationAlarm" />
<receiver android:name="com.embarcadero.notifications.FMXNot ificationAlarm" />

<receiver android:name="com.embarcadero.broadcastreceiver.In comingSms"
android:exported="true">
<intent-filter>
<action android:name="android.provider.Telephony.SMS_RECEI VED" />
</intent-filter>
</receiver>

<receiver android:name="com.embarcadero.firemonkey.broadcast .FMXBroadcastReceiverListener" />

<receiver android:name="com.embarcadero.firemonkey.broadcast .FMXBroadcastReceiver"
android:exported="true">
<intent-filter>
<action android:name="android.provider.telephony.SMS_RECEI VED" />
</intent-filter>
</receiver>


Und das sind Schnipsel aus meinem Delphi Code: AndroidBroadcastReceiver1 ist die Komponente

procedure TfrmHaupt.btnSendBroadcastClick(Sender: TObject);
begin
frmHaupt.AndroidBroadcastReceiver1.SendBroadcast(' SMS_RECEIVED_ACTION');
end;

procedure TfrmHaupt.FormCreate(Sender: TObject);
begin
frmHaupt.AndroidBroadcastReceiver1.RegisterReceive ;
frmHaupt.AndroidBroadcastReceiver1.Add('SMS_RECEIV ED_ACTION'); // stringinhalt selbst erfunden
…
end;



Delphicode der Komponente, beide nilcemar und Barisatalay sind in etwa gleich

unit batBroadcastReceiver;
interface
uses
System.SysUtils, System.Classes
{$IFDEF ANDROID}
,Androidapi.JNI.Embarcadero
,Androidapi.JNI.GraphicsContentViewText
,Androidapi.Helpers
,Androidapi.JNIBridge
,Androidapi.JNI.JavaTypes
,Androidapi.JNI.App
{$ENDIF}
;
type
{$IFNDEF ANDROID}
JIntent = class
end;
JContext = class
end;
{$ENDIF}

TAndroidBroadcastReceiver= class;
TOnReceive = procedure (csContext: JContext; csIntent: JIntent) of object;
{$IFDEF ANDROID}
TBroadcastListener = class(TJavaLocal, JFMXBroadcastReceiverListener)
private
FOwner: TAndroidBroadcastReceiver;
public
constructor Create(AOwner: TAndroidBroadcastReceiver);
procedure OnReceive(csContext: JContext; csIntent: JIntent); cdecl;
end;
{$ENDIF}


TAndroidBroadcastReceiver = class(TComponent)
private
{ Private declarations }
{$IFDEF ANDROID}
FReceiver: JBroadcastReceiver;
FListener : TBroadcastListener;
{$ENDIF}
FOnReceive: TOnReceive;
FItems: TStringList;
function GetItem(const csIndex: Integer): String;

protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure SendBroadcast(csValue: String);
procedure Add(csValue: String);
procedure Delete(csIndex: Integer);
procedure Clear;
{$IFDEF ANDROID}
procedure setResultData(data: JString);
{$ENDIF}
function Remove(const csValue: String): Integer;
function First: String;
function Last: String;
function HasPermission(const csPermission: string): Boolean;
procedure RegisterReceive;
property Item[const csIndex: Integer]: string read GetItem; default;
property Items: TStringList read FItems write FItems;
function StringFromByteArray(ABytes: System.TArray<System.Byte>): String;

published
{ Published declarations }
property OnReceive: TOnReceive read FOnReceive write FOnReceive;
end;

procedure Register;

implementation

procedure Register;
begin
RegisterComponents('BAT_Tecnologia', [TAndroidBroadcastReceiver]);
end;

{ TAndroidBroadcastReceiver }

procedure TAndroidBroadcastReceiver.Add(csValue: String);
{$IFDEF ANDROID}
var
Filter: JIntentFilter;
{$ENDIF}
begin
{$IFDEF ANDROID}
if (FListener = nil) or (FReceiver = nil) then
begin
Raise Exception.Create('First use RegisterReceive!');
Exit;
end;
{$ENDIF}

if FItems <> nil then
if FItems.IndexOf(csValue) = -1 then
begin
{$IFDEF ANDROID}
filter := TJIntentFilter.Create;
filter.addAction(StringToJString(csValue));
TAndroidHelper.Context.registerReceiver(FReceiver, filter);
{$ENDIF}
FItems.Add(csValue);
end;
end;

procedure TAndroidBroadcastReceiver.Clear;
begin
FItems.Clear;
end;

constructor TAndroidBroadcastReceiver.Create(AOwner: TComponent);
begin
inherited;
FItems := TStringList.Create;
end;


procedure TAndroidBroadcastReceiver.Delete(csIndex: Integer);
begin
if FItems <> nil then
begin
FItems.Delete(csIndex);
{$IFDEF ANDROID}
TAndroidHelper.Activity.UnregisterReceiver(FReceiv er);
RegisterReceive;
{$ENDIF}
end;
end;


destructor TAndroidBroadcastReceiver.Destroy;
begin
FItems.Free;
{$IFDEF ANDROID}
if FReceiver <> nil then
TAndroidHelper.Activity.UnregisterReceiver(FReceiv er);
{$ENDIF}
inherited;
end;


function TAndroidBroadcastReceiver.First: String;
begin
Result := FItems[0];
end;


function TAndroidBroadcastReceiver.GetItem(const csIndex: Integer): String;
begin
Result := FItems[csIndex];
end;

function TAndroidBroadcastReceiver.HasPermission(
const csPermission: string): Boolean;
{$IFDEF ANDROID}
begin
Result := TAndroidHelper.Activity.checkCallingOrSelfPermissi on(StringToJString(csPermission)) = TJPackageManager.JavaClass.PERMISSION_GRANTED;
{$ELSE}
begin
Result := False;
{$ENDIF}
end;



function TAndroidBroadcastReceiver.Last: String;
begin
Result := FItems[FItems.Count];
end;


procedure TAndroidBroadcastReceiver.RegisterReceive;
{$IFDEF ANDROID}
var
I: Integer;
begin
if FListener = nil then
FListener := TBroadcastListener.Create(Self);
if FReceiver = nil then
FReceiver := TJFMXBroadcastReceiver.JavaClass.init(FListener);
if FItems <> nil then
if FItems.Count > 0 then
for I := 0 to FItems.Count -1 do
Add(FItems[I]);
{$ELSE}
begin
{$ENDIF}
end;


function TAndroidBroadcastReceiver.Remove(const csValue: String): Integer;
begin
Result := FItems.IndexOf(csValue);
if Result > -1 then
FItems.Delete(Result);
end;


procedure TAndroidBroadcastReceiver.SendBroadcast(csValue: String);
{$IFDEF ANDROID}
var
Inx: JIntent;
begin
Inx := TJIntent.Create;
Inx.setAction(StringToJString(csValue));
TAndroidHelper.Context.sendBroadcast(Inx);
{$ELSE}
begin
{$ENDIF}
end;


function TAndroidBroadcastReceiver.StringFromByteArray(
ABytes: System.TArray<System.Byte>): String;
//convert a byte array to string
begin
Result := TEncoding.ANSI.GetString(ABytes);
end;

{$IFDEF ANDROID}
procedure TAndroidBroadcastReceiver.setResultData(data: JString);
begin
FReceiver.setResultData(data);
end;
{$ENDIF}


{ TBroadcastListener }

{$IFDEF ANDROID}
constructor TBroadcastListener.Create(AOwner: TAndroidBroadcastReceiver);
begin
inherited Create;
FOwner := AOwner;
end;

procedure TBroadcastListener.OnReceive(csContext: JContext; csIntent: JIntent);
begin
if Assigned(FOwner.OnReceive) then
FOwner.onReceive(csContext, csIntent);
end;
{$ENDIF}

end.