时间戳

首页 > 解决方案 > 应用程序关闭时如何每小时触发一次警报

java - 应用程序关闭时如何每小时触发一次警报

问题描述

我有一个生日应用程序，需要每天检查一次本地 SharedPreferences 数据，以查看某人的生日是否是那天。

到目前为止，我正在尝试做一些据称很简单的事情：即使我单击后退按钮、向上滑动以关闭应用程序、打开另一个应用程序、关闭手机（而不是关机）等，每分钟发送一个测试通知。很多其他应用程序这样做。

如果我能让这个大约每分钟的提醒工作，我可以调整它以显示来自 SharedPreferences 的数据，这没什么大不了的。然而有一个问题：

ALARMMANAGER 根本不像他们在文档中所说的那样工作。

我为我的警报管理器使用 setInexactRepeating 并让它触发一个名为“ReminderAlarm”的类，然后启动一个创建通知通道并构建测试通知的服务。问题是当我退出应用程序时，根本不会显示任何通知。但是，只要我打开应用程序，它们就会打开。所以由于某种原因，除非应用程序打开，否则 AlarmManager 不会触发。（我也用 Log.d 试过这个，如果应用程序打开，它也只会打印到日志中）

这是设置重复警报的原因：

 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_enter);
        ToggleButton toggle = (ToggleButton) findViewById(R.id.toggleButton);
        toggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if(isChecked) {
                    setAlarm();
                } else {
                    cancelAlarm();
                }
            }
        });
    }

    private void setAlarm() {
        alarmManager = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
        Intent intent = new Intent(this, ReminderAlarm.class);
        pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
        alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), 100, pendingIntent);
    }

    private void cancelAlarm() {
        //alarmManager.cancel(pendingIntent);
    }

这是警报接收器：（在清单中定义为接收器）

public class ReminderAlarm extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context, ReminderBuilderService.class);
        context.startService(i);
    }
}

这是提醒构建器服务：（在清单中定义为服务）

public class ReminderBuilderService extends Service {
    public final String CHANNEL_ID = "MainChannel";

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        createNotificationChannel();
        buildNotification();
        return super.onStartCommand(intent, flags, startId);
    }

    private void createNotificationChannel() {
        String name = "Birthday Notifications";
        String description = "Reminds you when your friends birthday approaches";
        int importance = NotificationManager.IMPORTANCE_HIGH;
        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
        channel.setDescription(description);
        NotificationManager notificationManager = getSystemService(NotificationManager.class);
        notificationManager.createNotificationChannel(channel);
    }
    private void buildNotification() {
        Context context = getApplicationContext();
        Intent openTap = new Intent(context, EnterActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, openTap, 0);

        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID);
        builder.setSmallIcon(R.drawable.pix_cake);
        builder.setContentTitle("TestNotification");
        builder.setStyle(new NotificationCompat.BigTextStyle()
                .bigText("TestText"));
        builder.setPriority(NotificationCompat.PRIORITY_HIGH);
        builder.setContentIntent(pendingIntent);
        builder.setAutoCancel(true);

        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
        notificationManager.notify(0, builder.build());
    }

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

大约每分钟都会显示一个通知（我知道 setInexactRepeating 不允许精确的重复计时），但它只显示应用程序何时打开

最后，这里是 Android Manifest xml

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

    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.SET_ALARM" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/main_icon"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/main_icon_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <receiver android:name=".ReminderAlarm"/>
        <activity android:name=".ListOfDaysActivity" />
        <activity android:name=".MainActivity" />
        <activity android:name=".EnterActivity"
            android:launchMode="singleInstance">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver android:name=".ReminderAlarm"/>
        <service android:name=".ReminderBuilderService"/>
    </application>
</manifest>

有什么我想念的吗？

标签： javaandroid

解决方案

您可以使用JobScheduler或AlarmManager可能达到您想要的结果。但是您应该使用的是WorkManager两者的抽象，具体取决于 Android 版本。

WorkManager是高度可配置的，将允许您创建一个PeriodicWorkRequest或一个OneTimeWorkRequest这些保证成功。PeriodicWorkRequest将在您安排工作以及在计时器中指定时触发。即使应用程序关闭或后台运行，它也会在后台执行。如果您不希望您的任务立即执行，您可以使用 PWR(PeriodicWorkRequest) 和FlexInterval。有关更多信息，请参阅下面的文档。

WorkManager 文档

WorkManager 架构

WorkmManager 代码实验室

例如，我创建了两个 PeriodicWorkRequests 来刷新服务并通过更新其令牌保持用户始终登录。当用户验证时PeriodicWorkRequest创建。就我而言，我不需要它立即触发，因为他们刚刚接收并缓存了此信息，因此我使用了 FlexInterval。当应用程序处于后台或关闭状态时，工作人员会继续每 12 小时刷新一次服务，并每 6 小时刷新一次令牌。它就像一个魅力。

这是一个例子：

构建工作：

 override fun beginWork() {

        val periodicWorkRequest = PeriodicWorkRequest.Builder(
                MyWorker::class.java,
                REPEAT_INTERVAL, TimeUnit.MINUTES, // How often work should repeat
                // Flex not required.
                FLEX_INTERVAL, TimeUnit.MINUTES) // Limits execution into a time window
                .setConstraints(
                     Constraints.Builder().setRequiredNetworkType(
                                       NetworkType.CONNECTED).build())
                .addTag(MY_WORKER_TAG)
                .build()

        WorkManager.getInstance().enqueueUniquePeriodicWork(
                MY_UNIQUE_WORK,
                ExistingPeriodicWorkPolicy.KEEP,
                periodicLoginRequest)

工人：

class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params) {

    override fun doWork(): Result {
            // DO WORK HERE

            Result.success()
        } else {
            // HANDLE FAILURE HERE
            Result.failure()
        }

上面是一个简单的实现，但它应该给你一个大致的想法。

推荐阅读