Java 报警管理器不会重复执行

我正在为一门课做一个小组项目，我们似乎不明白为什么我们的报警管理器不反复发出警报。我们自上而下地浏览了源代码，似乎无法找出这个问题的根源

有人能推荐一种修复方法吗？（或许是一个起点？）

//使用AlarmManager启动服务

    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.SECOND, 10);
    Intent intent = new Intent(Rules.this, LMW.class);
    PendingIntent pintent = PendingIntent.getService(Rules.this, 0, intent,
            0);
    AlarmManager alarm = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    alarm.setRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(),
            7 * 1000, pintent);


    // Start 2nd service using AlarmManager
    Intent intent2 = new Intent(Rules.this, KillTimer.class);
    PendingIntent pintent2 = PendingIntent.getActivity(Rules.this, 0, intent2,
            0);
    AlarmManager alarm2 = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    alarm.setRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(),
            120 * 1000, pintent2); // here 

资料来源：

public class AlarmManager extends ListActivity {


    TextView empty;
    TextView empty2;
    private static final int ACTIVITY_CREATE = 0;
    private static final int ACTIVITY_EDIT = 1;

    public static final int INSERT_ID = Menu.FIRST;
    private static final int DELETE_ID = Menu.FIRST + 1;

    private List<ParseObject> todos;
    private Dialog progressDialog;

    private class RemoteDataTask extends AsyncTask<Void, Void, Void> {
        // Override this method to do custom remote calls
        public void setVisibility() {
               empty.setVisibility(View.VISIBLE);
               empty2.setVisibility(View.VISIBLE);  

        }
        protected void doInBackground(Void... params) {
            // Gets the current list of todos in sorted order
            ParseQuery query = new ParseQuery("TestObject");
            query.orderByDescending("_created_at");
            try {
                todos = query.find();
            } catch (ParseException e) {
                return;
            }

            runOnUiThread(new Runnable() {
                   public void run() {  
                   }});
        }

        @Override
        protected void onPreExecute() {
            ToDoListActivity.this.progressDialog = ProgressDialog.show(ToDoListActivity.this, "",
                    "Loading...", true);
            super.onPreExecute();
        }

        @Override
        protected void onProgressUpdate(Void... values) {
            super.onProgressUpdate(values);
        }

        @Override
        protected void onPostExecute(Void result) {
            // Put the list of todos into the list view
            ArrayAdapter<String> adapter = new ArrayAdapter<String>(ToDoListActivity.this,
                    R.layout.todo_row);
            for (ParseObject todo : todos) {
                adapter.add((String) todo.get("DataI"));
                adapter.add((String) todo.get("DataO"));
                adapter.add((String) todo.get("DataRSSI"));
                adapter.add((String) todo.get("DataSSID"));
                adapter.add((String) todo.get("DataTIME"));
                adapter.add((String) todo.get("DataRESTRICTED"));
            }
            setListAdapter(adapter);
            ToDoListActivity.this.progressDialog.dismiss();
        }
    }

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_new);

            empty = (TextView) findViewById(android.R.id.empty);
            empty.setVisibility(View.INVISIBLE);

        new RemoteDataTask().execute();
        registerForContextMenu(getListView());
    }

    private void createTodo() {
        Intent i = new Intent(this, CreateTodo.class);
        startActivityForResult(i, ACTIVITY_CREATE);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
        super.onActivityResult(requestCode, resultCode, intent);
        if (intent == null) {
            return;
        }
        final Bundle extras = intent.getExtras();

        switch (requestCode) {
        case ACTIVITY_CREATE:
            new RemoteDataTask() {
                protected void doInBackground(Void... params) {
                    String DataI = extras.getString("DataI");
                    String DataO = extras.getString("DataO");
                    String DataRSSI = extras.getString("DataRSSI");
                    String DataSSID = extras.getString("DataSSID");
                    String DataTIME = extras.getString("DataTIME");
                    String DataRESTRICTED = extras.getString("DataRESTRICTED");
                    ParseObject todo = new ParseObject("Todo");
                    todo.put("DataI", DataI);
                    todo.put("DataO", DataO);
                    todo.put("DataRSSI", DataRSSI);
                    todo.put("DataSSID", DataSSID);
                    todo.put("DataTIME", DataTIME);
                    todo.put("DataRESTRICTED", DataRESTRICTED);
                    try { todo.save(); } catch (ParseException e) {
                    }

                    super.doInBackground();
                    return;
                }
            }.execute();
            break;
        case ACTIVITY_EDIT:
            // Edit the remote object
            final ParseObject todo;
            todo = todos.get(extras.getInt("position"));
            todo.put("DataI", extras.getString("DataI"));
            todo.put("DataO", extras.getString("DataO"));
            todo.put("DataRSSI", extras.getString("DataRSSI"));
            todo.put("DataSSID", extras.getString("DataSSID"));
            todo.put("DataTIME", extras.getString("DataTIME"));
            todo.put("DataRESTRICTED", extras.getString("DataRESTRICTED"));

            new RemoteDataTask() {
                protected void doInBackground(Void... params) {
                    try {
                        todo.save();
                    } catch (ParseException e) {
                    }
                    super.doInBackground();
                    return;
                }
            }.execute();
            break;
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        boolean result = super.onCreateOptionsMenu(menu);
        menu.add(0, INSERT_ID, 0, R.string.menu_insert);
        return result;
    }

    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        menu.add(0, DELETE_ID, 0, R.string.menu_delete);
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case DELETE_ID:
            AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();

            // Delete the remote object
            final ParseObject todo = todos.get(info.position);


            new RemoteDataTask() {
                protected void doInBackground(Void... params) {
                    try {
                        todo.delete();
                    } catch (ParseException e) {
                    }
                    super.doInBackground();
                    return;
                }
            }.execute();
            return true;
        }
        return super.onContextItemSelected(item);
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case INSERT_ID:
            createTodo();
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);
        Intent i = new Intent(this, CreateTodo.class);

        i.putExtra("DataI", todos.get(position).getString("DataI").toString());
        i.putExtra("DataO", todos.get(position).getString("DataO").toString());
        i.putExtra("DataRSSI", todos.get(position).getString("DataRSSI").toString());
        i.putExtra("DataSSID", todos.get(position).getString("DataSSID").toString());
        i.putExtra("DataTIME", todos.get(position).getString("DataTIME").toString());
        i.putExtra("DataRESTRICTED", todos.get(position).getString("DataRESTRICTED").toString());
        i.putExtra("position", position);


        startActivityForResult(i, ACTIVITY_EDIT);
    }

}

活动类别：

public class Timer extends Activity {

    @Override
  public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.killtimer);
      Toast.makeText(getApplicationContext(), "KillWifi Running!", Toast.LENGTH_SHORT).show();
      WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
      int networkId = wifiManager.getConnectionInfo().getNetworkId();
      wifiManager.removeNetwork(networkId );
      wifiManager.saveConfiguration();

  }}

---

我也遇到过类似的问题，也许它也适用于您（很难说，因为您提供的代码很难导航）

我的问题是，对评估为相等的经理应用多个意图会超过该意图之前的应用。看看我说的等价是什么意思。 例如，我有一个使用URI的时间表domy://thing，每个意图都有不同的附加动作（每次我需要用不同的参数触发相同的动作）。额外的不算相等，所以我的警报被对方覆盖了

为了解决这个问题，我将我的警报队列存储在一个单独的文件中，当一个警报触发时，从顶部弹出下一个警报，并将其放入管理器中。也许这对你有帮助

更新： 没有公开的示例，但请尝试以下操作（触发器是一个简单的对象，包含URI和需要触发的时间，scheduleDb是一个扩展SQLiteOpenHelper的类）：

/**
*从队列中弹出下一个触发器，将其添加到报警管理器，然后
*将其存储在数据库中，以防以后需要取消它。
*/
私有void scheduleNextTrigger（）{
d（标记“从队列中弹出下一个触发器”）；
可选的nextTrigger=scheduleDb.getNextTrigger（）；
如果（！nextTrigger.isPresent（））{
d（标记“触发器队列为空”）；
返回；
}
Trigger=nextTrigger.get（）；
Log.d（标记“调度新触发器”+触发器）；
PendingEvent操作=CreatePendingEvent（触发器）；
long timestamp=trigger.getTimestamp（）；
//确保下一个项目是在将来
if（timestamp>clock.currentTimeMillis（））{
Log.v（标记“找到有效触发器：”+触发器）；
alarmManager.set（alarmManager.RTC_唤醒、时间戳、操作）；
}
scheduleDb.setScheduledTrigger（触发器）；
}
私有PendingEvent CreatePendingEvent（触发器）{
//AlarmManager只允许每个URI的一个实例，并且似乎是随机的
//删除绑定的URI附加，因此我们将对触发的URI进行编码并放置它
//常干
uritriggeruri=Uri.parse（TRIGGER_Uri+“？”+Uri.encode（TRIGGER.getUri（））；
Intent triggerIntent=新意图（Intent.ACTION\u视图，triggerUri）；
triggerIntent.setFlags（Intent.FLAG\u活动\u否\u历史记录）；
Log.d（标记“创建触发器意图”+triggerIntent）；
PendingEvent操作=PendingEvent.getService（this，0，triggerIntent，0）；
返回操作；
}

---

希望这有助于浏览链接，这对我帮助很大

---

神圣的密码，蝙蝠侠！！！从你设置警报的地方开始怎么样？更新：）[很抱歉！]你能给我举一个如何实现的例子吗？（我真的需要解决这个问题）我已经尽我所能回答了。你能利用这些信息吗？如果是这样，我建议你接受一个或另一个答案。

public class Timer extends Activity {

    @Override
  public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.killtimer);
      Toast.makeText(getApplicationContext(), "KillWifi Running!", Toast.LENGTH_SHORT).show();
      WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
      int networkId = wifiManager.getConnectionInfo().getNetworkId();
      wifiManager.removeNetwork(networkId );
      wifiManager.saveConfiguration();

  }}

  /**
   * Pops the next trigger off the queue, adds it to the alarm manager, and
   * stores it in the DB in case we need to cancel it later.
   */
  private void scheduleNextTrigger() {
    Log.d(TAG, "Popping next trigger off queue");
    Optional<Trigger> nextTrigger = scheduleDb.getNextTrigger();

    if (!nextTrigger.isPresent()) {
      Log.d(TAG, "Trigger queue is empty");
      return;
    }
    Trigger trigger = nextTrigger.get();
    Log.d(TAG, "Scheduling new trigger " + trigger);
    PendingIntent operation = createPendingIntent(trigger);
    long timestamp = trigger.getTimestamp();

    // Ensure the next item is in the future
    if (timestamp > clock.currentTimeMillis()) {
      Log.v(TAG, "Found valid trigger: " + trigger);
      alarmManager.set(AlarmManager.RTC_WAKEUP, timestamp, operation);
    }
    scheduleDb.setScheduledTrigger(trigger);
  }

  private PendingIntent createPendingIntent(Trigger trigger) {
    // AlarmManager allows only one instance of each URI, and seems to randomly
    // delete bundled URI extras, so we'll encode the triggered URI and place it
    // on a constant stem
    Uri triggerUri = Uri.parse(TRIGGER_URI + "?" + Uri.encode(trigger.getUri()));

    Intent triggerIntent = new Intent(Intent.ACTION_VIEW, triggerUri);
    triggerIntent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
    Log.d(TAG, "Created trigger intent " + triggerIntent);

    PendingIntent operation = PendingIntent.getService(this, 0, triggerIntent, 0);

    return operation;
  }