Dauerhaft laufender Service, auch wenn App in Übersicht geschlossen wird

  • 14 Antworten
  • Letztes Antwortdatum
Status
Dieses Thema wurde gelöst! Zur Lösung springen…
AnnaBauer21

AnnaBauer21

Neues Mitglied
4
Hallo ihr Lieben,

ich hänge an einem Problem fest und verstehe nicht so ganz, warum das so nicht geht.
Vermutlich habe ich noch zu wenig Verständnis in der ganzen Thematik.
Und ich muss gestehen, alles was ich bis jetzt an Code habe ist aus dem Internet und ich verstehe teilweise nicht, warum das so gemacht wird.
Ich habe aktuell leider nicht die Zeit um mich genauer in diese Thematik einzuarbeiten und hoffe ihr könnt mir helfen das zum Laufen zu bringen :D

Folgendes möchte ich erreichen:
  • Nach dem Starten der App gibt es im Activity 2 Buttons
    • Service starten
    • Service beenden
  • Der Service soll dauerhaft weiterlaufen, auch wenn ich die App in der Übersicht schließe
  • Wenn ich jetzt wieder auf das App-Symbol drücke soll die GUI der App wieder geöffnet werden (und das geht aktuell leider nicht)

AndroidManifest.xml
XML:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="de.kugs.mydailyreminder">
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:screenOrientation="portrait"
        android:theme="@style/AppTheme">
        
        <activity
            android:name=".Activities.MainMenu"
            android:launchMode="singleTask"
            android:screenOrientation="portrait">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service android:name=".Helper.YourService"/>

        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="${applicationId}.fileprovider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/provider_paths" />
        </provider>
    </application>
</manifest>


MainMenu.java
Java:
@SuppressLint("SetTextI18n")
public class MainMenu extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        FirstStartActions();

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_mainmenu);

        final Button bu1 = findViewById(R.id.button1);
        bu1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startService(new Intent( getApplicationContext(), YourService.class ) );
            }
        });

        final Button bu2 = findViewById(R.id.button2);
        bu2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                stopService(new Intent( getApplicationContext(), YourService.class ) );
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
    }

    @Override
    protected void onDestroy(){
        super.onDestroy();
    }

    private void FirstStartActions() {
        if (ContextCompat.checkSelfPermission(MainMenu.this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(MainMenu.this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 1);
        }
        if (ContextCompat.checkSelfPermission(MainMenu.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(MainMenu.this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
        }
        if (ContextCompat.checkSelfPermission(MainMenu.this, Manifest.permission.FOREGROUND_SERVICE) != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(MainMenu.this, new String[]{Manifest.permission.FOREGROUND_SERVICE}, 1);
        }
        if (ContextCompat.checkSelfPermission(MainMenu.this, Manifest.permission.SYSTEM_ALERT_WINDOW) != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(MainMenu.this, new String[]{Manifest.permission.SYSTEM_ALERT_WINDOW}, 1);
        }
        if (ContextCompat.checkSelfPermission(MainMenu.this, Manifest.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS) != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(MainMenu.this, new String[]{Manifest.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS}, 1);
        }
    }
}


YourService.java
Java:
public class YourService extends Service {
    public YourService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId){
        onTaskRemoved(intent);

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Log.d("Service", "" + i++);
        startForegroundService(intent);
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public void onTaskRemoved(Intent rootIntent) {
        Intent restartServiceIntent = new Intent(getApplicationContext(),this.getClass());
        restartServiceIntent.setPackage(getPackageName());
        startService(restartServiceIntent);
        super.onTaskRemoved(rootIntent);
    }

    @Override
    public ComponentName startForegroundService(final Intent service) {
        return super.startForegroundService(service);
    }
}


Info:
  • Wenn ich die App in der Übersicht beende, läuft der Service dennoch weiter (Habe ich mit Logs im Logcat geprüft) allerdings wird onDestroy() nicht aufgerufen.
  • Wenn ich die App erneut öffne sehe ich nur weiß, allerdings wird jetzt onDestroy durchlaufen und ich sehe weiterhin die Logs des Services laufen.
  • Nach sehr sehr langer Zeit (5:30 Minuten) zeigt es mir endlich das MainMenu Activity an, bis dahin sind einige Logs eingegangen, ich weiß leider nicht was diese bedeuten.
    • Bash:
      2024-12-30 21:02:35.503 14053-14053/de.mydailyreminder D/_MainMenu_onDestroy
      2024-12-30 21:02:45.559 14053-14053/de.mydailyreminder I/Choreographer: Skipped 1208 frames!  The application may be doing too much work on its main thread.
      2024-12-30 21:03:25.665 14053-14053/de.mydailyreminder W/ActivityThread: handleWindowVisibility: no activity for token android.os.BinderProxy@1b045d6
      2024-12-30 21:03:25.682 14053-14053/de.mydailyreminder D/_MainMenu_onCreate
      2024-12-30 21:04:56.351 14053-14053/de.mydailyreminder I/Choreographer: Skipped 5412 frames!  The application may be doing too much work on its main thread.
      2024-12-30 21:06:26.814 14053-14058/de.mydailyreminder I/mydailyreminde: Compiler allocated 4MB to compile void android.widget.TextView.<init>(android.content.Context, android.util.AttributeSet, int, int)
      2024-12-30 21:07:56.998 14053-14053/de.mydailyreminder I/Choreographer: Skipped 10836 frames!  The application may be doing too much work on its main thread.
      2024-12-30 21:07:57.050 14053-14082/de.mydailyreminder D/EGL_emulation: eglMakeCurrent: 0x7f892d642f80: ver 3 1 (tinfo 0x7f891c8bb6c0)
      2024-12-30 21:07:57.073 14053-14082/de.mydailyreminder I/OpenGLRenderer: Davey! duration=180682ms; Flags=0, IntendedVsync=11531791668133, Vsync=11712391660909, OldestInputEvent=9223372036854775807, NewestInputEvent=0, HandleInputStart=11712402493540, AnimationStart=11712402768040, PerformTraversalsStart=11712407089640, DrawStart=11712408677140, SyncQueued=11712452209040, SyncStart=11712454714640, IssueDrawCommandsStart=11712454813540, SwapBuffers=11712456359840, FrameCompleted=11712476759940, DequeueBufferDuration=414000, QueueBufferDuration=808000,
  • Die Logs vom Service laufen weiterhin

Was übersehe ich? Was ist falsch oder muss anders gemacht werden?
Ich hoffe, ihr könnt mir helfen.
Vielen lieben Dank!
 
Empfohlene Antwort(en)
Frohes Neues Anna,

ich fange mal hinten an :
ich empfinde es als störend wenn dort Hinweise über im Hintergrund laufende Apps stehen, die man nicht wegwischen kann.
Das wäre nur bis Android 13 der Fall - ab da kann man sie wegwischen.

ABER :
Du bist mit dem ForegroundService bei deiner Anforderung dem Holzweg. (Kanonen auf Spatzen)
Ich vermute, du magst dir einen eigenen Wecker - ähnlich einem PillReminder - basteln.


Das was du benötigst, ist ein TimeScheduler , dem man die/mehrere Uhrzeit(en) vorgibt, wann er reagieren soll.
Kommt die Notification, soll mit einem Druck darauf die entsprechende Activity geöffnet werden - Richtig ?

Dazu kannst du dir den AlarmManager nehmen, oder besser die NachfolgeVariante wäre der WorkManager.

Achte darauf, dass du ab Android 13 auch noch eine zusätzlich Permisson beim Nutzer anfragen musst , um eine Notification erstellen zu können.
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

Ergo, deinen Service kannst du getrost in die Tonne hauen .....
 
Zuletzt bearbeitet:
  • Danke
Reaktionen: AnnaBauer21 und jogimuc
Alle Antworten (14)
Moin Anna,

sehr schwer, aus deinem Code die Ursache des Activity - Bugs direkt zu erkennen, denn auf den ersten Blick sieht es recht gut aus.

Deutet allerdings darauf hin, dass die UI zu viel ackern muss.

a)
Klammere mal bitte FirstStartActions(); und das Handling der Buttons aus
Startet dann die App ordungsgemäß beim zweiten Male ?

b)
Etwas Bauchschmerzen habe ich, dass du FirstStartActions(); vor der LayoutIniialisierung durchführst.
Setze Diese mal auch auf einen dritten Button-
Zweck : Gibt der UI erst mal Luft , Diese aufzubauen
Wenn das klappt , nimm einen Thread, warte ~ 2000ms und frage erst dann deine Permissions ab.
(Bei Fragen dazu -> melden)

c)
Wenn das nicht hilfft, dann

Code:
 @Override
    public void onTaskRemoved(Intent rootIntent) {
        Intent restartServiceIntent = new Intent(getApplicationContext(),this.getClass());
        restartServiceIntent.setPackage(getPackageName());
        startService(restartServiceIntent);
        super.onTaskRemoved(rootIntent);
    }

aus dem Service raus ... was bezweckst du damit ?



  • Der Service soll dauerhaft weiterlaufen, auch wenn ich die App in der Übersicht schließe
Bitte erkläre einmal genau, was der Service tun soll.

Bei Deinem Foregroundservice fehlt nämlich auch das komplette Notificatiion- Handling.

Hintergrund : Wenn ein (Foreground) Service startet, muss der Nutzer darüber mit einer Notification hingewiesen werden.
Bis A12 bleibt sie dauerhaft sichtbar, ab A13 kann man sie wegwischen (Service bleibt dennoch aktiv)
Mit einem Klick auf diese Notification (PendingIntent) soll sich dann i.d.R. die Activity öffnen


-----------------------------------------------------------------------------------------
Kleine Anmerkung :
Dieser wie auch die vorherigen Beiträge Deinerseits sind eine Wohltat - Präzise, verständlich im Layout , auf den Punkt gebracht und alle Informationen die man benötigt - da macht es Spass zu helfen .. :)

So Mancher kann sich da mal eine Scheibe abschneiden ....
 
Zuletzt bearbeitet:
  • Danke
Reaktionen: Lommel
Hallo swa00,

freut mich sehr, dass du mir wieder hilfst :D

Ich habe die Punkte a-c umgesetzt und es läuft nun um einiges schneller, aber leider noch nicht optimal. (1:20 statt 5:30 Min)

Bash:
2024-12-31 13:51:18.944 15557-15557/de.mydailyreminder D/_MainMenu_onDestroy
2024-12-31 13:51:28.982 15557-15557/de.mydailyreminder I/Choreographer: Skipped 604 frames!  The application may be doing too much work on its main thread.
2024-12-31 13:51:59.007 15557-15557/de.mydailyreminder W/ActivityThread: handleWindowVisibility: no activity for token android.os.BinderProxy@56a39ae
2024-12-31 13:51:59.025 15557-15557/de.mydailyreminder D/_MainMenu_onCreate
2024-12-31 13:52:19.256 15557-15557/de.mydailyreminder I/Choreographer: Skipped 1201 frames!  The application may be doing too much work on its main thread.
2024-12-31 13:52:39.656 15557-15557/de.mydailyreminder I/Choreographer: Skipped 1221 frames!  The application may be doing too much work on its main thread.
2024-12-31 13:52:39.904 15557-15627/de.mydailyreminder D/EGL_emulation: eglMakeCurrent: 0x7f892bde25c0: ver 3 1 (tinfo 0x7f891c1664c0)

Das Finale Ziel der App soll sein, dass ich die App starte, Einstellungen vornehme und ich täglich eine Erinnerung (Benachrichtigung) erhalte. (Gibt unzählige Apps, die sowas machen, aber da ich was spezielles brauche, wollte ich mir selbst eine einfache App ohne viel Schnickschnack schreiben).
Auch wenn die App (GUI) in der Übersicht geschlossen wird, möchte ich dennoch eine tägliche Benachrichtigung erhalten (dafür der Service). Wenn das Handy neu startet, soll der Service automatisch wieder starten.

Aktuell konzentriere ich mich aber darauf, dass der Service läuft und ich die App wieder öffnen kann, ohne dass es solange braucht.
Ich habe im Bezug auf Services folgende Aussage gefunden:
Caution: A service runs in the same process as the application in which it is declared and in the main thread of that application by default. If your service performs intensive or blocking operations while the user interacts with an activity from the same application, the service slows down activity performance. To avoid impacting application performance, start a new thread inside the service.

Trifft das evtl. auf mich zu?
Wie kann ich das in Verbindung mit startForegroundService umsetzen?
Und ist es überhaupt richtig, dass immer wieder startForegroundService aufgerufen wird?
 
Zuletzt bearbeitet:
Hallo Anna ,

a) Hast du auch die Anzahl von Skippes, wenn du nur a und b umsetzt ?
b) Ich bin mir mittlerweile nicht mehr sicher, ob du überhaupt einen Foregroundservice benötigst.
Welches Ereignis soll denn die Notifcation auslösen ? Zeit ? Datenänderung ?
Umreiße mal bitte, was das Ziel sein soll ...

Wie kann ich das in Verbindung mit startForegroundService umsetzen?
c) Könnte ich erst beantworten, wenn ich die Antwort von b hätte :)

Und ist es überhaupt richtig, dass immer wieder startForegroundService aufgerufen wird?
Nein
 
Zuletzt bearbeitet:
Hallo Stefan,
nur a + b bleibt unverändert, das ausschlaggebende für die Besserung war c.

Jeden Tag um eine bestimmte Uhrzeit möchte ich eine Benachrichtigung erhalten mit einem kurzen Text.
Beim Drücken darauf soll sich eine bestimmte Activity öffnen.

Was ich nicht möchte ist, dass während der Service läuft in der Statusleiste durchgehend was angezeigt wird, ich empfinde es als störend wenn dort Hinweise über im Hintergrund laufende Apps stehen, die man nicht wegwischen kann.
 
Frohes Neues Anna,

ich fange mal hinten an :
ich empfinde es als störend wenn dort Hinweise über im Hintergrund laufende Apps stehen, die man nicht wegwischen kann.
Das wäre nur bis Android 13 der Fall - ab da kann man sie wegwischen.

ABER :
Du bist mit dem ForegroundService bei deiner Anforderung dem Holzweg. (Kanonen auf Spatzen)
Ich vermute, du magst dir einen eigenen Wecker - ähnlich einem PillReminder - basteln.


Das was du benötigst, ist ein TimeScheduler , dem man die/mehrere Uhrzeit(en) vorgibt, wann er reagieren soll.
Kommt die Notification, soll mit einem Druck darauf die entsprechende Activity geöffnet werden - Richtig ?

Dazu kannst du dir den AlarmManager nehmen, oder besser die NachfolgeVariante wäre der WorkManager.

Achte darauf, dass du ab Android 13 auch noch eine zusätzlich Permisson beim Nutzer anfragen musst , um eine Notification erstellen zu können.
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

Ergo, deinen Service kannst du getrost in die Tonne hauen .....
 
Zuletzt bearbeitet:
  • Danke
Reaktionen: AnnaBauer21 und jogimuc
Hallo Stefan,

ich habs mit dem WorkManager gerade fertig getestet und es funktioniert wunderbar, auch dass die Notification kommt, obwohl die App beendet oder das Handy neu gestartet wurde!
Vielen lieben Dank für deine Hilfe :D
 
  • Danke
Reaktionen: swa00
Hallo Anna,

Immer wieder gerne :)
 
@swa00
Hallo Stefan,

ich bräuchte nochmal kurz deine Hilfe.
Irgendwas fehlt mir aktuell noch, die Notifications kommen nur, solange die App geöffnet ist.

Weißt du woran das liegen könnte?
Ich verwende nach wie vor Android 9 (API 28)

Und eine Frage zwischenrein, ich habe einiges dazu gelesen aber verstehe es dennoch nicht so ganz.
Ich möchte z.B. täglich um 10 Uhr eine Notification erhalten. Brauche ich dazu im PeriodicWorkRequest einen FlexInterval oder geht das auch ohne?

Bin mir gerade unsicher, an was das Problem liegen könnte.
Wenn die App geöffnet ist, komme ich im ReminderWorker in doWork, sobald die App geschlossen ist, geht er da scheinbar nicht mehr rein.
Mit einem OneTimeWorkRequest geht es auch, nachdem die App geschlossen wurde, aber mit dem PeriodicWorkRequest irgendwie nicht.

Manifest
XML:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

ReminderWorker
Java:
public class ReminderWorker extends Worker {
    Context context;

    public ReminderWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
        this.context = context;
    }

    @NonNull
    @Override
    public Result doWork() {
        // Daten aus Datenpaket vom ReminderHelper auslesen
        String id = getInputData().getString("ID");

        // Anhand XML ermitteln, welche Datei als nächstes dran ist
        String fileName = XmlHelper.GetNextFileName(id);

        // Benachrichtigung erstellen
        NotificationHelper.CreateNotification(context, "Nächste Lektion für '" + id + "'", fileName, id);

        return Result.success();
    }
}

ReminderHelper
Java:
public class ReminderHelper {
    ...

    private static void CreateWorkRequest(Context context, Long timeDelayInSeconds, int intervalInDays, String id) {
        // Datenpaket mit Daten für Reminder erstellen
        Data data = new Data.Builder()
                .putString("ID", id)
                .build();

        PeriodicWorkRequest periodicWork = new PeriodicWorkRequest.Builder(ReminderWorker.class,
                // TODO zum Testen auf kurze Zeit stellen
                //intervalInDays,
                //TimeUnit.DAYS)
                16,
                //TimeUnit.MINUTES)
                TimeUnit.MINUTES, 6, TimeUnit.MINUTES)
                //.setInitialDelay(timeDelayInSeconds, TimeUnit.SECONDS)
                .setInitialDelay(10, TimeUnit.SECONDS)
                .setInputData(data)
                .addTag(id)
                .build();

        // WorkRequest an WorkManager übergeben
        WorkManager.getInstance(context).enqueueUniquePeriodicWork(
                id,
                ExistingPeriodicWorkPolicy.REPLACE, periodicWork);
    }
}
 
Moin Anna,

versuchen wir mal der Sache auf den Grund zu gehen ....

Da ich nur ab API 30 arbeite (wie z.b. in der App in der Signatur) bin ich natürlich jetzt ein wenig verwirrt, warum der WorkManager bei dir nur dann funktioniert ( also doWork Trigger), wenn die App im Vordergrund ist.

Bei mir geht das Ding lediglich alle 15 Min im Hintergrund hin und requestet einen Link , und bei Bedarf schiesst es eine Notification .... und bis dato zickt es noch nicht rum.

Frage : Hat dein Device denn schon ein Battery-Optimzing ? Wenn ja, schon mal für die App deaktiviert ?


Aber, so wie ich das Lese , willst du ja nicht alle 15 Min eine Operation haben, sondern zu einer bestimmten Uhrzeit.
Natürlich geht das auch mit dem Workmanager , aber da er ja bei deinem Gerät nicht triggert - muss was Anders her - Schade !!

Hier mal zur Info der Uhrzeit - Workmanager

Java:
public void scheduleDailyNotification() {

    // WorkRequest erstellen
    WorkRequest dailyWorkRequest = new PeriodicWorkRequest.Builder(DailyNotificationWorker.class, 1, TimeUnit.DAYS)
            .setInitialDelay(calculateInitialDelay(10, 0), TimeUnit.MILLISECONDS)  // Start um 10:00 Uhr
            .build();
    // WorkManager ausführen
    WorkManager.getInstance(getApplicationContext()).enqueueUniquePeriodicWork(
            "DailyNotification",
            ExistingPeriodicWorkPolicy.REPLACE,  // Verhindert doppelte Ausführung
            (PeriodicWorkRequest) dailyWorkRequest
    );
}

private long calculateInitialDelay(int targetHour, int targetMinute) {
    Calendar current = Calendar.getInstance();
    Calendar target = Calendar.getInstance();
    target.set(Calendar.HOUR_OF_DAY, targetHour);
    target.set(Calendar.MINUTE, targetMinute);
    target.set(Calendar.SECOND, 0);

    if (target.before(current)) {
        target.add(Calendar.DAY_OF_YEAR, 1);
    }
    return target.getTimeInMillis() - current.getTimeInMillis();

}


Also probieren wir das Ganze mal mit dem AlarmManager :
ACHTUNG :
1739178632494.png


Vorweg, ich habe so etwas noch NICHT umgesetzt und für API 28 wird es für meine grauen Zellen schon ein wenig schwieriger, wie das denn mal war :)

Hier mal von mir "zusammengeschustert" - nicht getestet !!
a) du setzt den Alarmmanager

Java:
public void setDailyAlarm(Context context) {

    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    Intent intent = new Intent(context, NotificationReceiver.class);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);

    // Zeit für 10:00 Uhr setzen
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.HOUR_OF_DAY, 10);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);

    // Falls die Zeit schon vorbei ist, auf den nächsten Tag setzen
    if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
        calendar.add(Calendar.DAY_OF_YEAR, 1);
    }

    // Täglichen Alarm setzen
    alarmManager.setRepeating(
            AlarmManager.RTC_WAKEUP,
            calendar.getTimeInMillis(),
            AlarmManager.INTERVAL_DAY,
            pendingIntent
    );

}

b) dann baust du dir einen Broadcast-Receiver, der den Trigger vom AlarmManager abfängt und die Notification raushaut
Java:
public class NotificationReceiver extends BroadcastReceiver {

    @Override

    public void onReceive(Context context, Intent intent) {
        // Notification erstellen
        createNotification(context);
    }



    private void createNotification(Context context) {
        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        String channelId = "daily_notification_channel";

        // Für Android 8.0+ benötigst du einen Notification Channel
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                    channelId,
                    "Daily Notification",
                    NotificationManager.IMPORTANCE_HIGH

            );
            notificationManager.createNotificationChannel(channel);
        }

        // Erstelle die Notification
        Notification notification = new NotificationCompat.Builder(context, channelId)
                .setContentTitle("Tägliche Erinnerung")
                .setContentText("Dies ist deine tägliche Notification um 10:00 Uhr.")
                .setSmallIcon(R.drawable.ic_notification)
                .build();

        notificationManager.notify(100, notification);
    }
}

c) in der Manifest registierst du deinen Receiver
Code:
<application>    <receiver android:name=".NotificationReceiver" /></application>


Notfalls kannst du dann das Ganze noch in den BOOT_COMPLETED reinsetzen

P.S wie bekommst du denn diese schöne Java Formatierung im Code Tag hin ? - bin ich wohl zu blöde :)


[NACHTRAG]
ich sehe eben in deinem WorkManager Code, dass du das Intervall unter 15 Minuten hast -
Das wird nicht funktionieren
1739181429253.png
Arbeitsanfragen definieren | Background work | Android Developers

Deshalb habe ich auch 15 Min in meiner App
 
Zuletzt bearbeitet:
@swa00
swa00 schrieb:
P.S wie bekommst du denn diese schöne Java Formatierung im Code Tag hin ? - bin ich wohl zu blöde :)
beim code einfügen Java auswälen1739187276175.png
 
Zuletzt bearbeitet:
  • Danke
Reaktionen: swa00
@jogimuc

:1f44d:
Tja, wer hätte es gedacht , jetzt sieht es auch hübscher aus :)
 
Zuletzt bearbeitet:
  • Freude
Reaktionen: jogimuc
@swa00

Das Intervall steht auf 16 Minuten, das FlexIntervall auf 6, ich dachte mir jeweils 1 Minute über dem Minimalwert schadet beim testen nicht, um sicher zu gehen :1f605:

Danke für deine Mühe!
Ich schaus mir an, sobald ich den WorkManager nochmal mit API 30 getestet habe ;)
 
Hallo alle zusammen,

ich bin auf das Android Studio 2024.2.2 und API 30 umgestiegen.
Leider kamen die Notifications sowohl mit WorkManager als auch mit AlarmManager NICHT, wenn die App geschlossen wurde.
Sobald ich die App geöffnet habe, erhielt ich die ganzen Notifications.

LÖSUNG FÜR MICH:
Mit Release-Version der App an meinem Handy funktioniert es!
Ich habe immer übers Studio im Debug im Emulator getestet, hätte nicht gedacht, dass das einen Unterschied macht, wenn ich die Release-Apk im Emulator installiere, geht es dort auch...

Vielen Dank für eure Hilfe!
 
Zuletzt bearbeitet:
Zusatzinfo:
Ich hatte scheinbar 2 Probleme, ich habe innerhalb dem BoradcastReceiver beim AlarmManager / Worker beim WorkManager auf eine Constante zugegriffen, die dort immer null war.
Das war mir irgendwie nicht klar, dass die Constante nur zur Laufzeit der App vorhanden war und nach Beenden der App "abgebaut" wurde.
 
Status
Dieses Thema wurde gelöst! Zur Lösung springen…

Ähnliche Themen

L
  • lastvoidsignal
Antworten
2
Aufrufe
140
lastvoidsignal
L
E
Antworten
25
Aufrufe
2.068
evgkop
E
BerndFfm
Antworten
7
Aufrufe
783
swa00
swa00
Zurück
Oben Unten