it-swarm.com.de

Alarm Manager Beispiel

Ich möchte in meinem Projekt eine Zeitplanfunktion implementieren. Also habe ich nach einem Alarm-Manager-Programm gegoogelt, aber ich kann keine Beispiele finden.

Kann mir jemand mit einem grundlegenden Alarmmanagerprogramm helfen?

322

Dies ist ein Arbeitscode. Er weckt die CPU alle 10 Minuten, bis sich das Telefon ausschaltet.

Hinzufügen zu Manifest.xml:

...
<uses-permission Android:name="Android.permission.WAKE_LOCK"></uses-permission>
...
<receiver Android:process=":remote" Android:name=".Alarm"></receiver>
...

Code in Ihrer Klasse:

package yourPackage;
import Android.app.AlarmManager;
import Android.app.PendingIntent;
import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.os.PowerManager;
import Android.widget.Toast;

public class Alarm extends BroadcastReceiver 
{    
    @Override
    public void onReceive(Context context, Intent intent) 
    {   
        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "");
        wl.acquire();

        // Put here YOUR code.
        Toast.makeText(context, "Alarm !!!!!!!!!!", Toast.LENGTH_LONG).show(); // For example

        wl.release();
    }

    public void setAlarm(Context context)
    {
        AlarmManager am =( AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
        Intent i = new Intent(context, Alarm.class);
        PendingIntent pi = PendingIntent.getBroadcast(context, 0, i, 0);
        am.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), 1000 * 60 * 10, pi); // Millisec * Second * Minute
    }

    public void cancelAlarm(Context context)
    {
        Intent intent = new Intent(context, Alarm.class);
        PendingIntent sender = PendingIntent.getBroadcast(context, 0, intent, 0);
        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        alarmManager.cancel(sender);
    }
}

Alarm von Service einstellen:

package yourPackage;

import Android.app.Service;
import Android.content.Context;
import Android.content.Intent;
import Android.os.IBinder;

public class YourService extends Service
{
    Alarm alarm = new Alarm();
    public void onCreate()
    {
        super.onCreate();       
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) 
    {
        alarm.setAlarm(this);
        return START_STICKY;
    }

   @Override        
   public void onStart(Intent intent, int startId)
    {
        alarm.setAlarm(this);
    }

    @Override
    public IBinder onBind(Intent intent) 
    {
        return null;
    }
}

Wenn Sie die Alarmwiederholung beim Booten des Telefons einstellen möchten:

Fügen Sie die Berechtigung und den Dienst zu Manifest.xml hinzu:

<uses-permission Android:name="Android.permission.RECEIVE_BOOT_COMPLETED"></uses-permission>
...
<receiver Android:name=".AutoStart">
    <intent-filter>
        <action Android:name="Android.intent.action.BOOT_COMPLETED"></action>
    </intent-filter>
</receiver>
...
<service
        Android:name=".YourService"
        Android:enabled="true"
        Android:process=":your_service" >
</service>

Und erstelle eine neue Klasse:

package yourPackage;

import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;

public class AutoStart extends BroadcastReceiver
{   
    Alarm alarm = new Alarm();
    @Override
    public void onReceive(Context context, Intent intent)
    {   
        if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED))
        {
            alarm.setAlarm(context);
        }
    }
}
432
XXX

Ich habe die Lösung von XXX ausprobiert und sie hat anfangs funktioniert, aber irgendwann hat sie aufgehört zu funktionieren. Der onReceive wurde nie wieder angerufen. Ich habe stundenlang versucht, herauszufinden, was es sein könnte. Was mir klar wurde, war, dass das Intent aus irgendeinem mysteriösen Grund nicht mehr genannt wurde. Um dies zu umgehen, habe ich festgestellt, dass Sie wirklich eine Aktion für den Empfänger im Manifest angeben müssen. Beispiel:

<receiver Android:name=".Alarm" Android:exported="true">
    <intent-filter>
        <action Android:name="mypackage.START_ALARM" >
        </action>
    </intent-filter>
</receiver> 

Beachten Sie, dass der Name ".Alarm" mit dem Punkt ist. Erstellen Sie in der setAlarm -Methode von XXX das Intent wie folgt:

Intent i = new Intent("mypackage.START_ALARM");

Die Nachricht START_ALARM kann beliebig sein. Ich habe es nur zu Demonstrationszwecken benannt.

Ich habe keine im Manifest definierten Empfänger ohne einen Intent-Filter gesehen, der die Aktion angibt. Sie so zu erstellen, wie XXX es spezifiziert hat, wirkt wie ein Schwindel. Durch Angabe des Aktionsnamens wird Android gezwungen, eine Instanz von BroadcastReceiver mit der Klasse zu erstellen, die der Aktion entspricht. Wenn Sie sich auf den Kontext verlassen, beachten Sie, dass Android mehrere verschiedene Objekte hat, die ALLE als Kontext bezeichnet werden, und möglicherweise nicht dazu führen, dass Ihr BroadcastReceiver erstellt wird. Das Erzwingen von Android, eine Instanz Ihrer Klasse nur mit der Aktionsnachricht zu erstellen, ist weitaus besser, als sich auf einen zweifelhaften Kontext zu verlassen, der möglicherweise nie funktioniert.

52
AndroidDev

Hier ist ein ziemlich eigenständiges Beispiel. Nach 5 Sekunden wird ein Knopf rot.

    public void SetAlarm()
    {
        final Button button = buttons[2]; // replace with a button from your own UI
        BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override public void onReceive( Context context, Intent _ )
            {
                button.setBackgroundColor( Color.RED );
                context.unregisterReceiver( this ); // this == BroadcastReceiver, not Activity
            }
        };

        this.registerReceiver( receiver, new IntentFilter("com.blah.blah.somemessage") );

        PendingIntent pintent = PendingIntent.getBroadcast( this, 0, new Intent("com.blah.blah.somemessage"), 0 );
        AlarmManager manager = (AlarmManager)(this.getSystemService( Context.ALARM_SERVICE ));

        // set alarm to fire 5 sec (1000*5) from now (SystemClock.elapsedRealtime())
        manager.set( AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + 1000*5, pintent );
    }

Beachten Sie jedoch, dass der AlarmManager auch dann ausgelöst wird, wenn Ihre Anwendung nicht ausgeführt wird. Wenn Sie diese Funktion aufrufen und die Home-Taste drücken, 5 Sekunden warten und dann in Ihre App zurückkehren, wird die Taste rot.

Ich weiß nicht, welche Art von Verhalten Sie erhalten würden, wenn Ihre App überhaupt nicht im Speicher wäre. Seien Sie also vorsichtig mit dem Zustand, den Sie beibehalten möchten.

25
amr

MainActivity.Java

package com.example.alarmexample;  

import Android.app.Activity;  
import Android.app.AlarmManager;  
import Android.app.PendingIntent;  
import Android.content.Intent;  
import Android.os.Bundle;  
import Android.view.View;  
import Android.view.View.OnClickListener;  
import Android.widget.Button;  
import Android.widget.EditText;  
import Android.widget.Toast;  

public class MainActivity extends Activity {  
Button b1;  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main); 

        startAlert();  

}   public void startAlert() { 
        int timeInSec = 2;

        Intent intent = new Intent(this, MyBroadcastReceiver.class);  
        PendingIntent pendingIntent = PendingIntent.getBroadcast(  
                                      this.getApplicationContext(), 234, intent, 0);  
        AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);  
        alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + (timeInSec * 1000), pendingIntent);  
        Toast.makeText(this, "Alarm set to after " + i + " seconds",Toast.LENGTH_LONG).show();  
    }  

}

MyBroadcastReceiver.Java

package com.example.alarmexample;  

import Android.content.BroadcastReceiver;  
import Android.content.Context;  
import Android.content.Intent;  
import Android.media.MediaPlayer;  
import Android.widget.Toast;  

public class MyBroadcastReceiver extends BroadcastReceiver {  
    MediaPlayer mp;  
    @Override  
    public void onReceive(Context context, Intent intent) {  
        mp=MediaPlayer.create(context, R.raw.alarm);  
        mp.start();  
        Toast.makeText(context, "Alarm", Toast.LENGTH_LONG).show();  
    }  
}  

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>  
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"  
    package="com.example.alarmexample" >  

    <uses-permission Android:name="Android.permission.VIBRATE" />  


    <application  
        Android:allowBackup="true"  
        Android:icon="@drawable/ic_launcher"  
        Android:label="@string/app_name"  
        Android:theme="@style/AppTheme" >  

        <activity  
            Android:name="com.example.alarmexample.MainActivity"  
            Android:label="@string/app_name" >  
            <intent-filter>  
                <action Android:name="Android.intent.action.MAIN" />  

                <category Android:name="Android.intent.category.LAUNCHER" />  
            </intent-filter>  
        </activity>  

        <receiver Android:name="MyBroadcastReceiver" >  
        </receiver>  
    </application>  

</manifest>  
14
M.Usman

AlarmManager in Kombination mit IntentService

Ich denke, das beste Muster für die Verwendung von AlarmManager ist die Zusammenarbeit mit einem IntentService. Das IntentService wird vom AlarmManager ausgelöst und handhabt die erforderlichen Aktionen über die Empfangsabsicht. Diese Struktur hat keine Auswirkungen auf die Leistung wie die Verwendung von BroadcastReceiver. Ich habe einen Beispielcode für diese Idee in kotlin entwickelt, der hier verfügbar ist:

MyAlarmManager.kt

import Android.app.AlarmManager
import Android.app.PendingIntent
import Android.content.Context
import Android.content.Intent

object MyAlarmManager {

    private var pendingIntent: PendingIntent? = null

    fun setAlarm(context: Context, alarmTime: Long, message: String) {
        val alarmManager: AlarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager

        val intent = Intent(context, MyIntentService::class.Java)
        intent.action = MyIntentService.ACTION_SEND_TEST_MESSAGE
        intent.putExtra(MyIntentService.EXTRA_MESSAGE, message)

        pendingIntent = PendingIntent.getService(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
        alarmManager.set(AlarmManager.RTC_WAKEUP, alarmTime, pendingIntent)
    }

    fun cancelAlarm(context: Context) {
        pendingIntent?.let {
            val alarmManager: AlarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
            alarmManager.cancel(it)
        }
    }

}

MyIntentService.kt

import Android.app.IntentService
import Android.content.Intent

class MyIntentService : IntentService("MyIntentService") {

    override fun onHandleIntent(intent: Intent?) {
        intent?.apply {
            when (intent.action) {
                ACTION_SEND_TEST_MESSAGE -> {
                    val message = getStringExtra(EXTRA_MESSAGE)
                    println(message)
                }
            }
        }
    }

    companion object {
        const val ACTION_SEND_TEST_MESSAGE = "ACTION_SEND_TEST_MESSAGE"
        const val EXTRA_MESSAGE = "EXTRA_MESSAGE"
    }

}

manifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
    package="com.aminography.alarm">

    <application
        ... >

    <service
        Android:name="path.to.MyIntentService"
        Android:enabled="true"
        Android:stopWithTask="false" />

    </application>

</manifest>

Verwendung:

val calendar = Calendar.getInstance()
calendar.add(Calendar.SECOND, 10)
MyAlarmManager.setAlarm(applicationContext, calendar.timeInMillis, "Test Message!")

Wenn Sie den geplanten Alarm abbrechen möchten, versuchen Sie Folgendes:

MyAlarmManager.cancelAlarm(applicationContext)
2
aminography

Mit diesem Code können Sie einen sich wiederholenden Alarm auslösen. Die Wiederholungszeit können Sie einstellen.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
     <LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
     xmlns:tools="http://schemas.Android.com/tools"
     Android:layout_width="match_parent"
     Android:layout_height="match_parent"
     Android:orientation="vertical" 
     Android:background="#000000"
     Android:paddingTop="100dp">

    <LinearLayout
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    Android:gravity="center" >

    <EditText
        Android:id="@+id/ethr"
    Android:layout_width="50dp"
    Android:layout_height="wrap_content"
    Android:ems="10"
    Android:hint="Hr"
    Android:singleLine="true" >


        <requestFocus />
    </EditText>

    <EditText
        Android:id="@+id/etmin"
    Android:layout_width="55dp"
    Android:layout_height="wrap_content"

    Android:ems="10"
    Android:hint="Min"
    Android:singleLine="true" />

    <EditText
        Android:id="@+id/etsec"
    Android:layout_width="50dp"
    Android:layout_height="wrap_content"

    Android:ems="10"
    Android:hint="Sec"
    Android:singleLine="true" />

    </LinearLayout>

   <LinearLayout
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content" 
    Android:gravity="center"
    Android:paddingTop="10dp">


    <Button
        Android:id="@+id/setAlarm"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:onClick="onClickSetAlarm"
        Android:text="Set Alarm" />

</LinearLayout>

</LinearLayout>

MainActivity.Java

public class MainActivity extends Activity {
    int hr = 0;
    int min = 0;
    int sec = 0;
    int result = 1;

    AlarmManager alarmManager;
    PendingIntent pendingIntent;
    BroadcastReceiver mReceiver;

    EditText ethr;
    EditText etmin;
    EditText etsec;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ethr = (EditText) findViewById(R.id.ethr);
        etmin = (EditText) findViewById(R.id.etmin);
        etsec = (EditText) findViewById(R.id.etsec);
        RegisterAlarmBroadcast();
    } 

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

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

    public void onClickSetAlarm(View v) {
        String shr = ethr.getText().toString();
        String smin = etmin.getText().toString();
        String ssec = etsec.getText().toString();

        if(shr.equals("")) 
            hr = 0;
        else {
            hr = Integer.parseInt(ethr.getText().toString());
            hr=hr*60*60*1000;
        }

        if(smin.equals(""))
            min = 0;
        else {
            min = Integer.parseInt(etmin.getText().toString());
            min = min*60*1000;
        }

        if(ssec.equals(""))
            sec = 0;
        else {
             sec = Integer.parseInt(etsec.getText().toString());
             sec = sec * 1000;
        }
        result = hr+min+sec;
        alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), result , pendingIntent); 
    }

    private void RegisterAlarmBroadcast() {
        mReceiver = new BroadcastReceiver() {
            // private static final String TAG = "Alarm Example Receiver";
            @Override
            public void onReceive(Context context, Intent intent) {
                Toast.makeText(context, "Alarm time has been reached", Toast.LENGTH_LONG).show();
            }
        };

        registerReceiver(mReceiver, new IntentFilter("sample"));
        pendingIntent = PendingIntent.getBroadcast(this, 0, new Intent("sample"), 0);
        alarmManager = (AlarmManager)(this.getSystemService(Context.ALARM_SERVICE));
    }

    private void UnregisterAlarmBroadcast() {
        alarmManager.cancel(pendingIntent); 
        getBaseContext().unregisterReceiver(mReceiver);
    }
}

Wenn Sie den Alarm nur einmal benötigen, ersetzen Sie ihn

alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), result , pendingIntent);

mit

 alarmManager.set( AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + result , pendingIntent );
2
Jose Kurian

Ich habe meine eigene Implementierung erstellt, um dies auf möglichst einfache Weise zu tun.

import Android.app.AlarmManager;
import Android.app.PendingIntent;
import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.content.IntentFilter;

import junit.framework.Assert;

/**
 * Created by Daniel on 28/08/2016.
 */
public abstract class AbstractSystemServiceTask {

    private final Context context;
    private final AlarmManager alarmManager;
    private final BroadcastReceiver broadcastReceiver;
    private final PendingIntent pendingIntent;

    public AbstractSystemServiceTask(final Context context, final String id, final long time, final AlarmType alarmType, final BackgroundTaskListener backgroundTaskListener) {

        Assert.assertNotNull("ApplicationContext can't be null", context);
        Assert.assertNotNull("ID can't be null", id);

        this.context = context;

        this.alarmManager = (AlarmManager) this.context.getSystemService(Context.ALARM_SERVICE);

        this.context.registerReceiver(
                this.broadcastReceiver = this.getBroadcastReceiver(backgroundTaskListener),
                new IntentFilter(id));

        this.configAlarmManager(
                this.pendingIntent = PendingIntent.getBroadcast(this.context, 0, new Intent(id), 0),
                time,
                alarmType);
    }

    public void stop() {

        this.alarmManager.cancel(this.pendingIntent);
        this.context.unregisterReceiver(this.broadcastReceiver);
    }

    private BroadcastReceiver getBroadcastReceiver(final BackgroundTaskListener backgroundTaskListener) {

        Assert.assertNotNull("BackgroundTaskListener can't be null.", backgroundTaskListener);

        return new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {

                backgroundTaskListener.perform(context, intent);
            }
        };
    }

    private void configAlarmManager(final PendingIntent pendingIntent, final long time, final AlarmType alarmType) {

        long ensurePositiveTime = Math.max(time, 0L);

        switch (alarmType) {
            case REPEAT:
                this.alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), ensurePositiveTime, pendingIntent);
                break;
            case ONE_TIME:
            default:
                this.alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + ensurePositiveTime, pendingIntent);
        }
    }

    public interface BackgroundTaskListener {

        void perform(Context context, Intent intent);

    }

    public enum AlarmType {

        REPEAT, ONE_TIME;

    }

}

Der einzige nächste Schritt ist die Implementierung.

import Android.content.Context;
import Android.content.Intent;
import Android.util.Log;

import ...AbstractSystemServiceTask;

import Java.util.concurrent.TimeUnit;

/**
 * Created by Daniel on 28/08/2016.
 */
public class UpdateInfoSystemServiceTask extends AbstractSystemServiceTask {

    private final static String ID = "UPDATE_INFO_SYSTEM_SERVICE";
    private final static long REPEAT_TIME = TimeUnit.SECONDS.toMillis(10);
    private final static AlarmType ALARM_TYPE = AlarmType.REPEAT;

    public UpdateInfoSystemServiceTask(Context context) {

        super(context, ID, REPEAT_TIME, ALARM_TYPE, new BackgroundTaskListener() {

            @Override
            public void perform(Context context, Intent intent) {

                Log.i("MyAppLog", "-----> UpdateInfoSystemServiceTask");

                //DO HERE WHATEVER YOU WANT...
            }
        });

        Log.i("MyAppLog", "UpdateInfoSystemServiceTask started.");
    }

}

Ich arbeite gerne mit dieser Implementierung, aber es ist auch eine gute Möglichkeit, die Klasse AbstractSystemServiceTask nicht zu abstrahieren und über einen Builder zu erstellen.

Ich hoffe es hilft dir.

UPDATED Verbessert, um mehrere BackgroundTaskListener auf demselben BroadCastReceiver zuzulassen.

import Android.app.AlarmManager;
import Android.app.PendingIntent;
import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.content.IntentFilter;

import junit.framework.Assert;

import Java.util.HashSet;
import Java.util.Set;

/**
 * Created by Daniel on 28/08/2016.
 */
public abstract class AbstractSystemServiceTask {

    private final Context context;
    private final AlarmManager alarmManager;
    private final BroadcastReceiver broadcastReceiver;
    private final PendingIntent pendingIntent;

    private final Set<BackgroundTaskListener> backgroundTaskListenerSet;

    public AbstractSystemServiceTask(final Context context, final String id, final long time, final AlarmType alarmType) {

        Assert.assertNotNull("ApplicationContext can't be null", context);
        Assert.assertNotNull("ID can't be null", id);

        this.backgroundTaskListenerSet = new HashSet<>();

        this.context = context;

        this.alarmManager = (AlarmManager) this.context.getSystemService(Context.ALARM_SERVICE);

        this.context.registerReceiver(
                this.broadcastReceiver = this.getBroadcastReceiver(),
                new IntentFilter(id));

        this.configAlarmManager(
                this.pendingIntent = PendingIntent.getBroadcast(this.context, 0, new Intent(id), 0),
                time,
                alarmType);
    }

    public synchronized void registerTask(final BackgroundTaskListener backgroundTaskListener) {

        Assert.assertNotNull("BackgroundTaskListener can't be null", backgroundTaskListener);

        this.backgroundTaskListenerSet.add(backgroundTaskListener);
    }

    public synchronized void removeTask(final BackgroundTaskListener backgroundTaskListener) {

        Assert.assertNotNull("BackgroundTaskListener can't be null", backgroundTaskListener);

        this.backgroundTaskListenerSet.remove(backgroundTaskListener);
    }

    public void stop() {

        this.backgroundTaskListenerSet.clear();

        this.alarmManager.cancel(this.pendingIntent);
        this.context.unregisterReceiver(this.broadcastReceiver);
    }

    private BroadcastReceiver getBroadcastReceiver() {

        return new BroadcastReceiver() {

            @Override
            public void onReceive(final Context context, final Intent intent) {

                for (BackgroundTaskListener backgroundTaskListener : AbstractSystemServiceTask.this.backgroundTaskListenerSet) {

                    backgroundTaskListener.perform(context, intent);
                }
            }
        };
    }

    private void configAlarmManager(final PendingIntent pendingIntent, final long time, final AlarmType alarmType) {

        long ensurePositiveTime = Math.max(time, 0L);

        switch (alarmType) {
            case REPEAT:
                this.alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), ensurePositiveTime, pendingIntent);
                break;
            case ONE_TIME:
            default:
                this.alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + ensurePositiveTime, pendingIntent);
        }
    }

    public interface BackgroundTaskListener {

        void perform(Context context, Intent intent);

    }

    public enum AlarmType {

        REPEAT, ONE_TIME;

    }

}
1
Dani

Hier ist ein Beispiel mit Alarm Manager unter Verwendung von Kotlin:

class MainActivity : AppCompatActivity() {

    val editText: EditText by bindView(R.id.edit_text)
    val timePicker: TimePicker by bindView(R.id.time_picker)
    val buttonSet: Button by bindView(R.id.button_set)
    val buttonCancel: Button by bindView(R.id.button_cancel)
    val relativeLayout: RelativeLayout by bindView(R.id.activity_main)
    var notificationId = 0

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        timePicker.setIs24HourView(true)

        val alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager

        buttonSet.setOnClickListener {
            if (editText.text.isBlank()) {
                Toast.makeText(applicationContext, "Title is Required!!", Toast.LENGTH_SHORT).show()
                [email protected]
            }
            alarmManager.set(
                AlarmManager.RTC_WAKEUP,
                Calendar.getInstance().apply {
                    set(Calendar.HOUR_OF_DAY, timePicker.hour)
                    set(Calendar.MINUTE, timePicker.minute)
                    set(Calendar.SECOND, 0)
                }.timeInMillis,
                PendingIntent.getBroadcast(
                    applicationContext,
                    0,
                    Intent(applicationContext, AlarmBroadcastReceiver::class.Java).apply {
                        putExtra("notificationId", ++notificationId)
                        putExtra("reminder", editText.text)
                    },
                    PendingIntent.FLAG_CANCEL_CURRENT
                )
            )
            Toast.makeText(applicationContext, "SET!! ${editText.text}", Toast.LENGTH_SHORT).show()
            reset()
        }

        buttonCancel.setOnClickListener {
            alarmManager.cancel(
                PendingIntent.getBroadcast(
                    applicationContext, 0, Intent(applicationContext, AlarmBroadcastReceiver::class.Java), 0))
            Toast.makeText(applicationContext, "CANCEL!!", Toast.LENGTH_SHORT).show()
        }
    }

    override fun onTouchEvent(event: MotionEvent?): Boolean {
        (getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager)
            .hideSoftInputFromWindow(relativeLayout.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
        relativeLayout.requestFocus()
        return super.onTouchEvent(event)
    }

    override fun onResume() {
        super.onResume()
        reset()
    }

    private fun reset() {
        timePicker.apply {
            val now = Calendar.getInstance()
            hour = now.get(Calendar.HOUR_OF_DAY)
            minute = now.get(Calendar.MINUTE)
        }
        editText.setText("")
    }
}
0
ARGeo

Alarm Manager:

Zum XML-Layout hinzufügen (* Diese Ansicht beim Erstellen in der Hauptaktivität aufrufen)

  <TimePicker
    Android:id="@+id/timepicker"
    Android:layout_width="match_parent"
    Android:layout_height="0dp"
    Android:layout_weight="2"></TimePicker>

  <Button
    Android:id="@+id/btn_start"
    Android:text="start Alarm"
    Android:onClick="start_alarm_event"
    Android:layout_width="match_parent"
    Android:layout_height="52dp" />

Zum Manifest hinzufügen (Innerhalb des Anwendungstags && außerhalb der Aktivität)

 <receiver Android:name=".AlarmBroadcastManager"
        Android:enabled="true"
        Android:exported="true"/>

AlarmBroadcastManager-Klasse erstellen (von BroadcastReceiver erben)

 public class AlarmBroadcastManager extends BroadcastReceiver{
    @Override
    public void onReceive(Context context, Intent intent) {
      MediaPlayer mediaPlayer=MediaPlayer.create(context,Settings.System.DEFAULT_RINGTONE_URI);
      mediaPlayer.start();
    }
 }

In der Hauptaktivität (diese Funktionen hinzufügen):

 @RequiresApi(api = Build.VERSION_CODES.M)
 public  void start_alarm_event(View view){
    Calendar calendar=Calendar.getInstance();
    calendar.set(
    calendar.get(Calendar.YEAR),
    calendar.get(Calendar.MONTH),
    calendar.get(Calendar.DAY_OF_MONTH),
    timePicker.getHour(),
    timePicker.getMinute(),
    0
    );
    setAlarm(calendar.getTimeInMillis());
 }

 public void setAlarm(long timeInMillis){
    AlarmManager alarmManager=(AlarmManager) getSystemService(Context.ALARM_SERVICE);
    Intent intent=new Intent(this,AlarmBroadcastManager.class);
    PendingIntent pendingIntent=PendingIntent.getBroadcast(this,0,intent,0);
     alarmManager.setRepeating(AlarmManager.RTC_WAKEUP,timeInMillis,AlarmManager.INTERVAL_DAY,pendingIntent);
    Toast.makeText(getApplicationContext(),"Alarm is Set",Toast.LENGTH_SHORT).show();


 }
0