Fatal编程技术网
  • java/
  • Java 警报管理器在Android中不适用于多个警报

Java 警报管理器在Android中不适用于多个警报

java android

Java 警报管理器在Android中不适用于多个警报,java,android,broadcastreceiver,scheduled-tasks,alarmmanager,Java,Android,Broadcastreceiver,Scheduled Tasks,Alarmmanager,我想使用基于一些数据库时间值的报警。目前，我的闹钟只适用于一个闹钟，比如：我有3个闹钟设置在上午8:30、上午10:20和下午12:20 我的闹钟只为一个值工作。这是我正在创建的提醒类 public class OwnGoalReminder extends EventReminder { GoalOwn goalOwn; int interValTime; int goalId; int hour; int minute; int request

我想使用基于一些数据库时间值的报警。目前，我的闹钟只适用于一个闹钟，比如：我有3个闹钟设置在上午8:30、上午10:20和下午12:20 我的闹钟只为一个值工作。这是我正在创建的提醒类

public class OwnGoalReminder extends EventReminder {
    GoalOwn goalOwn;
    int interValTime;
    int goalId;
    int hour;
    int minute;
    int requestCode;
    String type;

    public void setInterValTime(int interValTime) {
        this.interValTime = interValTime;
    }

    public int getHour() {
        return hour;
    }

    public void setHour(int hour) {
        this.hour = hour;
    }
    public void setRequestCode(int requestCode) {
        this.requestCode = requestCode;
    }
    public void setType(String type) {
        this.type = type;
    }

    public int getMinute() {
        return minute;
    }
    @Override
    protected int getGoalId(){return this.goalId;}

    public void setMinute(int minute) {
        this.minute = minute;
    }

    public OwnGoalReminder(Context context , int goalId, int interValTime){
        super(context);
        this.interValTime = interValTime;
        this.goalId = goalId;
    }

    @Override
    protected String getType() {
        return this.type;
    }


    @Override
    protected String getMessage() {
        return "Reminder!!! You should check your goals!";
    }

    @Override
    protected int getRequestCode() {
        return requestCode;
    }

    @Override
    protected EventTime getEventTime() {
        int h = hour;
        int m = minute;
        return new EventTime(hour,minute,interValTime);
    }

    @Override
    protected Class getBroadcastReceiver() {
        return MyBroadcastReceiver.class;
    }
}
这是OwnGOalReminder的基类

public abstract class EventReminder{
    protected Context context;
    protected Alarm alarm;
    PushNotificationsManager notificationsManager;


    public void remind() {
        Bundle bundle = new Bundle();
        bundle.putString("type", getType());
        bundle.putString("msg", getMessage());
        notificationsManager.sendNotification(bundle);
    }

    protected abstract String getType();

    protected abstract String getMessage();

    protected abstract int getRequestCode();
    protected abstract int getGoalId();

    protected abstract EventTime getEventTime();

    protected abstract Class getBroadcastReceiver();

    protected EventReminder(Context context){
        this.context = context;
        alarm = new Alarm(context, getBroadcastReceiver());
        notificationsManager = new PushNotificationsManager(context);
    }

    public void startReminder(){
        alarm.startAlert(getRequestCode(), getGoalId(), getEventTime().hour, getEventTime().minute, getEventTime().intervalInMinute);
        //alarm.setAlarm(context, getEventTime().hour, getEventTime().minute);
    }


    protected class EventTime{
        int hour, minute, intervalInMinute;
        public EventTime(int hour, int minute, int intervalInMinute){
            this.hour = hour;
            this.minute = minute;
            this.intervalInMinute = intervalInMinute;
        }
    }
}
这是alarm类，我正在创建alarmmanager

public class Alarm{

    private final Context context;
    private Class broadcastReceiver;

    public Alarm(Context context, Class broadcastReceiver){
        this.context = context;
        this.broadcastReceiver = broadcastReceiver;
    }

    public void startAlert(int requestCode, int gid, int hour, int minute, int intervalMinute) {
        Log.d(this.getClass().getName(), "starting alert");
        int i = 10;
        Long timeToMilliSeconds = timeToMilliSeconds(hour, minute);
        Intent intent = new Intent(context, MyBroadcastReceiver.class);
        intent.putExtra("reqcode", requestCode);
        intent.putExtra("time", timeToMilliSeconds);
        intent.putExtra("gid" , gid);

        PendingIntent pendingIntent = PendingIntent.getBroadcast(
                context, requestCode, intent, PendingIntent.FLAG_UPDATE_CURRENT);
        AlarmManager alarmManager = (AlarmManager) context.getSystemService(ALARM_SERVICE);
        alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, timeToMilliSeconds+
                + (i * 1000), 1000*60*intervalMinute, pendingIntent);
        //Toast.makeText(context, "Alarm set in " + i + " seconds",Toast.LENGTH_LONG).show();
    }

    @NonNull
    public static long timeToMilliSeconds(int hour, int minute) {
        Date dat  = new Date();//initializes to now
        Calendar cal_alarm = Calendar.getInstance();
        Calendar cal_now = Calendar.getInstance();
        cal_now.setTime(dat);
        cal_alarm.setTime(dat);
        cal_alarm.set(Calendar.HOUR_OF_DAY,hour);//set the alarm time
        cal_alarm.set(Calendar.MINUTE, minute);
        cal_alarm.set(Calendar.SECOND,0);

        if(cal_alarm.getTimeInMillis() < System.currentTimeMillis()){
            cal_alarm.add(Calendar.DAY_OF_YEAR,1);
        }
        return cal_alarm.getTimeInMillis();
    }

}

公共类报警{
私人最终语境；
专用类广播接收机；
公共警报（上下文、类广播接收器）{
this.context=上下文；
this.broadcastReceiver=broadcastReceiver；
}
public void startAlert（int requestCode、int gid、int hour、int minute、int intervalMinute）{
Log.d（this.getClass（）.getName（），“启动警报”）；
int i=10；
Long-timeToMilliSeconds=timeToMilliSeconds（小时，分钟）；
意向意向=新意向（上下文，MyBroadcastReceiver.class）；
intent.putExtra（“请求代码”，requestCode）；
intent.putExtra（“时间”，timetomills）；
意向。额外（“gid”，gid）；
PendingIntent PendingIntent=PendingIntent.getBroadcast(
上下文、请求代码、意图、PendingEvent.FLAG_UPDATE_CURRENT）；
AlarmManager AlarmManager=（AlarmManager）context.getSystemService（报警服务）；
alarmManager.setInexactRepeating（alarmManager.RTC_唤醒，时间毫秒+
+（i*1000），1000*60*间隔分钟，悬挂式）；
//Toast.makeText（上下文，“报警设置在“+i+”秒内”，Toast.LENGTH_LONG.show（）；
}
@非空
公共静态长时间毫秒（整数小时，整数分钟）{
Date dat=new Date（）；//初始化为现在
Calendar cal_alarm=Calendar.getInstance（）；
Calendar cal_now=Calendar.getInstance（）；
立即校准设定时间（dat）；
校准报警设置时间（dat）；
cal_alarm.set（Calendar.HOUR_OF_DAY，HOUR）；//设置报警时间
校准报警设置（日历分钟，分钟）；
校准报警设置（日历秒，0）；
如果（校准报警.getTimeMillis（）
这就是我根据数据库值创建多个报警对象的方法

public static void registerAlarm(Context context){
        if(!UserPreferences.isAlarmRegistered(context)) {
            GoalReminder goalReminder = new GoalReminder(context);


            AppraisalReminder appraisalReminder = new AppraisalReminder(context);
            goalReminder.startReminder();
            appraisalReminder.startReminder();
           // ownGoalReminder.startReminder();
            //UserPreferences.setIsAlarmRegistered(context,true);
            ArrayList<Goal> LIST_OF_OWN_GOALS = new ArrayList<>();

            LIST_OF_OWN_GOALS = (ArrayList<Goal>) Goal.getGoalFromOwnGoals();

            for (Goal g : LIST_OF_OWN_GOALS) {
                OwnGoalReminder ownGoalReminder = new OwnGoalReminder(context , g.getgId(),3 );
                int h = Integer.parseInt(g.getrTime())/60;
                int min = Integer.parseInt(g.getrTime())%60;
                ownGoalReminder.setHour(h);
                ownGoalReminder.setMinute(min);
                ownGoalReminder.setRequestCode(16);

                ownGoalReminder.setType("16");
                ownGoalReminder.startReminder();
                LIST_OF_OWN_REMINDERS.add(ownGoalReminder);

            }



        }
    }

publicstaticvoidregisteralARM（上下文）{
如果（！UserPreferences.isAlarmRegistered（上下文））{
GoalReminder GoalReminder=新的GoalReminder（上下文）；
估价提醒估价提醒=新估价提醒（上下文）；
goalReminder.startReminder（）；
评估提醒。startReminder（）；
//ownGoalReminder.startReminder（）；
//setIsAlarmRegistered（上下文，true）；
ArrayList列出自己的目标=新建ArrayList（）；
列出自己的目标=（ArrayList）目标。getGoalFromOwnGoals（）；
目标g：列出自己的目标{
OwnGoalReminder OwnGoalReminder=新的OwnGoalReminder（上下文，g.getgId（），3）；
inth=Integer.parseInt（g.getrTime（））/60；
int min=Integer.parseInt（g.getrTime（））%60；
设定小时（h）；
ownGoalReminder.setMinute（分钟）；
ownGoalReminder.setRequestCode（16）；
ownGoalReminder.setType（“16”）；
ownGoalReminder.startReminder（）；
列出自己的提醒。添加（ownGoalReminder）；
}
}
}
这是我的广播接收器类：

public class MyBroadcastReceiver extends BroadcastReceiver {
    private static final String[] goalMessagesArray = ApraiseApplication.getContext().getResources().getStringArray(R.array.goals_messages);
    private static Queue<String> goalMessagesQueue = new ArrayDeque<>(Arrays.asList(goalMessagesArray));


    private static final String[] appraisalsMessagesArray = ApraiseApplication.getContext().getResources().getStringArray(R.array.appraisals_messages);
    private static Queue<String> appraisalsMessagesQueue = new ArrayDeque<>(Arrays.asList(appraisalsMessagesArray));

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d(this.getClass().getName(), "notify");
        PushNotificationsManager notificationsManager = new PushNotificationsManager(context);
        PowerManager.WakeLock wl = acquireWakeLock(context);

        int requestCode = intent.getIntExtra("reqcode",1);
        int gId = intent.getIntExtra("gid",1);

        long time = intent.getLongExtra("time",0);
        String message = "";

        // it will create the instance of Random class
          Random randomGenerator = new Random();

        // it will generate a random number based on  goal message arrayList length
        int indexForGoalMessage = randomGenerator.nextInt(goalMessagesArray.length);

        // it will generate a random number based on  appraisalsMessagesArray length
        int indexForAppraisalsMessage = randomGenerator.nextInt(goalMessagesArray.length);
        String gid = "";


        if(isNotifyTimePassed(time)){
            //return;
        }


        if(requestCode == 123){

//           if(goalMessagesQueue.isEmpty()){
//                goalMessagesQueue = new ArrayDeque<>(Arrays.asList(goalMessagesArray));
//            }
//            message = goalMessagesQueue.poll();

            message = goalMessagesArray[indexForGoalMessage];



        }else if(requestCode == 124){

//            if(appraisalsMessagesQueue.isEmpty()){
//                appraisalsMessagesQueue = new ArrayDeque<>(Arrays.asList(appraisalsMessagesArray));
//            }
//            message = appraisalsMessagesQueue.poll();

            message = appraisalsMessagesArray[indexForAppraisalsMessage];


        }

            Bundle bundle = new Bundle();
            bundle.putString("type", Integer.toString(requestCode));
            bundle.putString("msg", message);
            bundle.putString("gid" , String.valueOf(gId));
            notificationsManager.sendNotification(bundle);

             wl.release();
    }

    @NonNull
    private PowerManager.WakeLock acquireWakeLock(Context context) {
        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "");
        wl.acquire();
        return wl;
    }

    private boolean isNotifyTimePassed(long time) {
        return (System.currentTimeMillis()-time) > 1000L*60L*5L;
    }

}

公共类MyBroadcastReceiver扩展了BroadcastReceiver{
私有静态最终字符串[]goalMessagesArray=ApraiseApplication.getContext（）.getResources（）.getStringArray（R.array.goals_消息）；
私有静态队列goalMessageQueue=newArrayQueue（Arrays.asList（goalMessageArray））；
私有静态最终字符串[]评估消息array=ApraiseApplication.getContext（）.getResources（）.getStringArray（R.array.evaluations\u消息）；
private static Queue evaluationmessagesquee=new ArrayDeque（Arrays.asList（evaluationmessagesarray））；
@凌驾
公共void onReceive（上下文、意图）{
Log.d（this.getClass（）.getName（），“notify”）；
PushNotificationsManager notificationsManager=新的PushNotificationsManager（上下文）；
PowerManager.WakeLock wl=acquireWakeLock（上下文）；
int requestCode=intent.getIntExtra（“请求代码”，1）；
int gId=intent.getIntExtra（“gId”，1）；
长时间=intent.getLongExtra（“时间”，0）；
字符串消息=”；
//它将创建Random类的实例
Random randomGenerator=新的Random（）；
//它将根据目标消息arrayList长度生成一个随机数
int indexForGoalMessage=randomGenerator.nextInt（goalMessageArray.length）；
//它将根据EvaluationMessagesArray长度生成一个随机数
int indexForAppraisalsMessage=randomGenerator.nextInt（goalMessagesArray.length）；
字符串gid=“”；
如果（isNotifyTimePassed（时间））{
//返回；
}
if（requestCode==123）{
//if（goalMessagesQueue.isEmpty（））{
//goalMessageQueue=newArrayQueue（Arrays.asList（goalMessageArray））；
//            }
//message=goalMessagesQueue.poll（）；
message=goalMessageArray[indexForGoalMessage]；
}else if（请求代码==124）{
//if（evaluationMessageSqueue.isEmpty（））{
//evaluationMessagesQueue=newArrayQue（Arrays.asList（evaluationMessagesArray））；
//            }
//message=evaluationMessageSqueue.poll（）；
message=evaluationmessagesarray[indexforapprisalsmessage]；
}
Bundle=新Bundle（）；
bundle.putString（“type”，Integer.toString（requestCode））；
bundle.putString（“msg”，消息）；
小面包

final int intent_id= (int) System.currentTimeMillis(); 

  PendingIntent pendingIntent = PendingIntent.getBroadcast(
                context, intent_id , intent,   PendingIntent.FLAG_UPDATE_CURRENT);