Esempio n. 1
1
  public void alarmFacebookUserComming(Message callbackMessage) {
    Log.d(TAG, "alarmFacebookUserComming");

    Message msg = handler.obtainMessage(FACEBOOK_FRIENDS_GET);
    if (callbackMessage != null) {
      msg.getData().putParcelable(CALLBACK, callbackMessage);
      msg.getData().putLong("hisuid", callbackMessage.getData().getLong("hisuid", -1));
    }
    handler.sendMessageDelayed(msg, 1 * 1000);

    long nexttime = System.currentTimeMillis() + getFriendsTimeout() * 1000L;

    if (SNSService.TEST_LOOP) {
      nexttime = System.currentTimeMillis() + 90 * 1000;
    }

    AlarmManager alarmMgr = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);

    Intent i = new Intent();
    i.setClassName("com.ast.free", "com.ast.free.service.SNSService");
    i.setAction("com.ast.free.intent.action.FACEBOOK_USER");
    PendingIntent userpi =
        PendingIntent.getService(
            mContext.getApplicationContext(), 0, i, PendingIntent.FLAG_CANCEL_CURRENT);
    alarmMgr.set(AlarmManager.RTC_WAKEUP, nexttime, userpi);
  }
Esempio n. 2
1
    /**
     * In order to update notification from the AlarmSender.
     *
     * @param oldName <code>String</code> - old name
     * @param oldDescription <code>String</code> - old description
     * @param oldDate <code>String</code> - old date
     * @param newName <code>String</code> - new name
     * @param newDescription <code>String</code> - new description
     * @param newDate <code>String</code> - new date
     */
    @android.webkit.JavascriptInterface
    public void updateAlarmPerToDoItem(
        String oldName,
        String oldDescription,
        String oldDate,
        String newName,
        String newDescription,
        String newDate) {
      long oldTime = ParseDateToTimeStamp(oldDate);
      Intent oldIntent = new Intent(MainActivity.this, NotificationService.class);
      oldIntent.putExtra("name", oldName);
      oldIntent.putExtra("description", oldDescription);
      oldIntent.putExtra("time", oldTime);
      int oldId = (oldName + oldDescription + oldTime).hashCode();
      oldIntent.setData(Uri.parse(String.valueOf(oldId)));
      PendingIntent oldPendingIntent =
          PendingIntent.getService(
              MainActivity.this, 0, oldIntent, PendingIntent.FLAG_UPDATE_CURRENT);
      AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
      alarmManager.cancel(oldPendingIntent);

      long newTime = ParseDateToTimeStamp(newDate);
      Intent newIntent = new Intent(MainActivity.this, NotificationService.class);
      oldIntent.putExtra("name", newName);
      oldIntent.putExtra("description", newDescription);
      oldIntent.putExtra("time", newTime);
      int newId = (newName + newDescription + newTime).hashCode();
      newIntent.setData(Uri.parse(String.valueOf(newId)));
      PendingIntent newPendingIntent =
          PendingIntent.getService(
              MainActivity.this, 0, newIntent, PendingIntent.FLAG_UPDATE_CURRENT);
      alarmManager.set(AlarmManager.RTC_WAKEUP, newTime, newPendingIntent);
    }
  @Test
  public void cancel_removesMatchingPendingIntents() {
    Intent newIntent = new Intent(Robolectric.application.getApplicationContext(), String.class);
    PendingIntent pendingIntent =
        PendingIntent.getBroadcast(
            Robolectric.application.getApplicationContext(),
            0,
            newIntent,
            PendingIntent.FLAG_UPDATE_CURRENT);
    alarmManager.set(AlarmManager.RTC, 1337, pendingIntent);

    Intent newIntent2 = new Intent(Robolectric.application.getApplicationContext(), Integer.class);
    PendingIntent pendingIntent2 =
        PendingIntent.getBroadcast(
            Robolectric.application.getApplicationContext(),
            0,
            newIntent2,
            PendingIntent.FLAG_UPDATE_CURRENT);
    alarmManager.set(AlarmManager.RTC, 1337, pendingIntent2);

    assertEquals(2, shadowAlarmManager.getScheduledAlarms().size());

    Intent newIntent3 = new Intent(Robolectric.application.getApplicationContext(), String.class);
    PendingIntent newPendingIntent =
        PendingIntent.getBroadcast(
            Robolectric.application.getApplicationContext(),
            0,
            newIntent3,
            PendingIntent.FLAG_UPDATE_CURRENT);
    alarmManager.cancel(newPendingIntent);
    assertEquals(1, shadowAlarmManager.getScheduledAlarms().size());
  }
Esempio n. 4
0
  public static void LaunchAt(Context in_context, WorkingTime wrk_time) {
    Calendar to_fire = wrk_time.start_date;
    Calendar to_kill = wrk_time.stop_date;

    MUUDebug.Log(cl_nm, "Start time " + to_fire.getTime().toString());
    MUUDebug.Log(cl_nm, "Stop time " + to_kill.getTime().toString());

    AlarmManager alarmManager = (AlarmManager) in_context.getSystemService(Context.ALARM_SERVICE);

    Intent serv_intent = new Intent(in_context, ChkPrice.class);

    PendingIntent pendingIntent =
        PendingIntent.getService(
            in_context.getApplicationContext(),
            SERV_START_REQ_CODE,
            serv_intent,
            PendingIntent.FLAG_CANCEL_CURRENT); // Flag might be adjusted

    Intent killer = new Intent(in_context, SQServiceKiller.class);
    PendingIntent sender =
        PendingIntent.getBroadcast(
            in_context.getApplicationContext(),
            SERV_KILLER_REQ_CODE,
            killer,
            PendingIntent.FLAG_CANCEL_CURRENT);

    alarmManager.cancel(pendingIntent);
    alarmManager.cancel(sender);

    alarmManager.set(AlarmManager.RTC_WAKEUP, to_fire.getTimeInMillis(), pendingIntent);
    alarmManager.set(AlarmManager.RTC_WAKEUP, to_kill.getTimeInMillis(), sender);
  }
 @Test
 public void setShouldReplaceDuplicates() {
   alarmManager.set(
       AlarmManager.ELAPSED_REALTIME,
       0,
       PendingIntent.getActivity(activity, 0, new Intent(activity, activity.getClass()), 0));
   alarmManager.set(
       AlarmManager.ELAPSED_REALTIME,
       0,
       PendingIntent.getActivity(activity, 0, new Intent(activity, activity.getClass()), 0));
   assertEquals(1, shadowAlarmManager.getScheduledAlarms().size());
 }
  @Override
  public final void onReceive(final Context context, final Intent intent) {
    if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED)) {

      SharedPreferences sharedPreferences =
          context.getSharedPreferences(WeatherSettings.WEATHER_SETTING, 0);
      boolean reset = sharedPreferences.getBoolean(WeatherSettings.RESET_KEY, false);

      Intent service = new Intent(context, ActionBootService.class);
      startWakefulService(context, service);

      if (reset == true) {
        Calendar myCal = Calendar.getInstance();
        myCal.set(Calendar.HOUR_OF_DAY, MainActivity.RESET_HOUR);
        myCal.set(Calendar.MINUTE, MainActivity.RESET_MINUTE);

        Intent someIntent = new Intent(context.getApplicationContext(), ResetAlarmReceiver.class);
        PendingIntent pendingIntent =
            PendingIntent.getBroadcast(
                context.getApplicationContext(), MainActivity.REPEATING, someIntent, 0);

        AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        am.set(AlarmManager.RTC_WAKEUP, myCal.getTimeInMillis(), pendingIntent);
      }
    }
  }
  /** Schedules an alarm to go off a few minutes before this talk. */
  private void scheduleNotification(Talk talk) {
    // We need to know the time slot of the talk, so fetch its data if we haven't already.
    if (!talk.isDataAvailable()) {
      Talk.getInBackground(
          talk.getObjectId(),
          new GetCallback<Talk>() {
            @Override
            public void done(Talk talk, ParseException e) {
              if (talk != null) {
                scheduleNotification(talk);
              }
            }
          });
      return;
    }

    // Figure out what time we need to set the alarm for.
    Date talkStart = null != talk.getSlot() ? talk.getSlot().getStartTime() : null;
    if (BuildConfig.DEBUG) {
      Logger.getLogger(getClass().getName()).log(Level.INFO, "Registering alarm for " + talkStart);
    }
    long fiveMinutesBefore = null != talkStart ? talkStart.getTime() - (5000 * 60) : Long.MAX_VALUE;
    if (fiveMinutesBefore < System.currentTimeMillis()) {
      return;
    }

    // Register the actual alarm.
    AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    PendingIntent pendingIntent = getPendingIntent(talk);
    manager.set(AlarmManager.RTC_WAKEUP, fiveMinutesBefore, pendingIntent);
  }
 private void refresh() {
   Intent intent = new Intent(this, SplashActivity.class); // CampusdishclientActivity.class);
   PendingIntent p = PendingIntent.getActivity(this, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);
   AlarmManager mgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
   mgr.set(AlarmManager.RTC, System.currentTimeMillis(), p);
   System.exit(0);
 }
Esempio n. 9
0
  /**
   * Schedules alarms for a single task
   *
   * @param shouldPerformPropertyCheck whether to check if task has requisite properties
   */
  @SuppressWarnings("nls")
  private void scheduleAlarm(Metadata alarm) {
    if (alarm == null) return;

    long taskId = alarm.getValue(Metadata.TASK);
    int type = ReminderService.TYPE_ALARM;

    Context context = ContextManager.getContext();
    Intent intent = new Intent(context, Notifications.class);
    intent.setType("ALARM" + Long.toString(taskId)); // $NON-NLS-1$
    intent.setAction(Integer.toString(type));
    intent.putExtra(Notifications.ID_KEY, taskId);
    intent.putExtra(Notifications.TYPE_KEY, type);

    AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, 0);

    long time = alarm.getValue(AlarmFields.TIME);
    if (time == 0 || time == NO_ALARM) am.cancel(pendingIntent);
    else if (time > DateUtilities.now()) {
      if (Constants.DEBUG)
        Log.e("Astrid", "Alarm (" + taskId + ", " + type + ") set for " + new Date(time));
      am.set(AlarmManager.RTC_WAKEUP, time, pendingIntent);
    }
  }
Esempio n. 10
0
  public void testAM(String index, int hour, int minute) {

    try {
      long atime = System.currentTimeMillis();

      Calendar curTime = Calendar.getInstance();
      curTime.set(Calendar.HOUR_OF_DAY, hour);
      curTime.set(Calendar.MINUTE, minute);
      curTime.set(Calendar.SECOND, 0);
      curTime.set(Calendar.MILLISECOND, 0);
      long btime = curTime.getTimeInMillis();
      long triggerTime = btime;
      if (atime > btime) triggerTime += 1000 * 60 * 60 * 24;
      Intent intentMyService;
      intentMyService = new Intent(index);
      AlarmManager am = (AlarmManager) context.getSystemService(context.ALARM_SERVICE);
      PendingIntent sender = PendingIntent.getBroadcast(context, 0, intentMyService, 0);

      // 서비스 시작
      am.set(AlarmManager.RTC, triggerTime, sender);
    } catch (Exception e) {
      Log.d("MpMainActivity", e.getMessage() + "");

      e.printStackTrace();
    }
  }
Esempio n. 11
0
  /** 5分钟后开启注册的与参数匹配的闹铃服务 */
  public void onStartService() {

    intent = new Intent(context, AlarmReceiver.class);
    intent.setAction(AlarmAction);
    intent.putExtra("ringStr", ringStr);
    intent.putExtra("medd_name", name);
    intent.putExtra("medd_num", num);
    intent.putExtra("medd_unit", unit);
    System.out.println(
        "ringStr="
            + ringStr
            + "//"
            + "medd_name="
            + name
            + "//"
            + "medd_num="
            + num
            + "//"
            + "medd_unit="
            + unit);
    pendingIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
    int type = AlarmManager.RTC_WAKEUP;
    alarmManager.set(type, currentTime + 5 * 60 * 1000, pendingIntent);
    System.out.println("5分钟服务开启  ");
  }
  public static void setAlarm(Context context) {
    SharedPreferences prefs = AnonymousStats.getPreferences(context);
    if (prefs.contains(AnonymousStats.ANONYMOUS_OPT_IN)) {
      migrate(context, prefs);
    }
    if (!Utilities.isStatsCollectionEnabled(context)) {
      initiateOptOut(context);
      return;
    }
    long lastSynced = prefs.getLong(AnonymousStats.ANONYMOUS_LAST_CHECKED, 0);
    if (lastSynced == 0) {
      launchService(context, true); // service will reschedule the next alarm
      return;
    }
    long millisFromNow = (lastSynced + UPDATE_INTERVAL) - System.currentTimeMillis();

    Intent intent = new Intent(ACTION_LAUNCH_SERVICE);
    intent.setClass(context, ReportingServiceManager.class);

    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    alarmManager.set(
        AlarmManager.RTC_WAKEUP,
        System.currentTimeMillis() + millisFromNow,
        PendingIntent.getBroadcast(context, 0, intent, 0));
    Log.d(TAG, "Next sync attempt in : " + (millisFromNow / MILLIS_PER_HOUR) + " hours");
  }
Esempio n. 13
0
 public static void scheduleTrainScheduleRequest(
     Context context, AlarmManager alarmManager, int munitesToNextExecute) {
   alarmManager.set(
       AlarmManager.RTC,
       System.currentTimeMillis() + munitesToNextExecute * 60 * 1000,
       createBroadcastPI(context, createIntent(context, TRAIN_SCHEDULE_REQUEST)));
 }
Esempio n. 14
0
  public void rescheduleNotificationSync(boolean force) {
    AlarmManager alarmMgr = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
    long nexttime;

    long current_time = System.currentTimeMillis();
    long last_sync_time = orm.getNotificationLastTime();
    long donespan = (current_time - last_sync_time);
    long left_time = Long.valueOf(orm.getNotificationInterval()) * sync_period - donespan;
    if (donespan < 0 || left_time <= 0) {
      long waittime = 1;
      for (int i = 0; i < nErrorCount && i < 10; i++) {
        waittime = waittime * 2;
      }
      nexttime = System.currentTimeMillis() + 1 * 60 * 1000 * waittime;
    } else {
      nexttime = System.currentTimeMillis() + left_time;
    }

    if (force == true) {
      nexttime = System.currentTimeMillis() + 1 * 60 * 1000;
    }

    if (SNSService.TEST_LOOP) {
      nexttime = System.currentTimeMillis() + 1 * 60 * 1000;
    }

    Intent i = new Intent();
    i.setClassName("oms.sns.facebook", SERVICE);
    i.setAction(ACTION);
    PendingIntent phonebookpi =
        PendingIntent.getService(
            mContext.getApplicationContext(), 0, i, PendingIntent.FLAG_CANCEL_CURRENT);
    alarmMgr.set(AlarmManager.RTC_WAKEUP, nexttime, phonebookpi);
  }
 public static void setReminder(
     Context context,
     long id,
     String title,
     long dueDate,
     long listId,
     long reminderDate,
     long reminderInterval) {
   String actionName = context.getResources().getString(R.string.intent_action_alarm);
   Intent alarmIntent = new Intent(actionName);
   alarmIntent.putExtra(NotificationUtils.ID, id);
   alarmIntent.putExtra(NotificationUtils.TITLE, title);
   alarmIntent.putExtra(NotificationUtils.DUE_DATE, dueDate);
   alarmIntent.putExtra(NotificationUtils.LIST_ID, listId);
   PendingIntent alarmPendingIntent =
       PendingIntent.getBroadcast(context, getNotificationId(id), alarmIntent, 0);
   AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
   if (reminderInterval > 0) {
     alarmManager.setRepeating(
         AlarmManager.RTC_WAKEUP, reminderDate, reminderInterval, alarmPendingIntent);
     if (Log.LOGV) Log.v("TaskDetailDialog set recurring reminder at " + dueDate);
   } else {
     alarmManager.set(AlarmManager.RTC_WAKEUP, reminderDate, alarmPendingIntent);
     if (Log.LOGV) Log.v("TaskDetailDialog set reminder at " + dueDate);
   }
 }
  public static void setAlarm(Context context, long millisFromNow) {
    SharedPreferences prefs = AnonymousStats.getPreferences(context);
    boolean optedIn = prefs.getBoolean(AnonymousStats.ANONYMOUS_OPT_IN, true);
    if (!optedIn) {
      return;
    }

    if (millisFromNow <= 0) {
      long lastSynced = prefs.getLong(AnonymousStats.ANONYMOUS_LAST_CHECKED, 0);
      if (lastSynced == 0) {
        // never synced, so let's fake out that the last sync was just now.
        // this will allow the user tFrame time to opt out before it will start
        // sending up anonymous stats.
        lastSynced = System.currentTimeMillis();
        prefs.edit().putLong(AnonymousStats.ANONYMOUS_LAST_CHECKED, lastSynced).apply();
        Log.d(ReportingService.TAG, "Set alarm for first sync.");
      }
      millisFromNow = (lastSynced + UPDATE_INTERVAL) - System.currentTimeMillis();
    }

    Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
    intent.setClass(context, ReportingServiceManager.class);

    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    alarmManager.set(
        AlarmManager.RTC_WAKEUP,
        System.currentTimeMillis() + millisFromNow,
        PendingIntent.getBroadcast(context, 0, intent, 0));
    Log.d(
        ReportingService.TAG,
        "Next sync attempt in : " + millisFromNow / MILLIS_PER_HOUR + " hours");
  }
  private void startNavigating() {
    if (!mStarted) {
      if (DEBUG) Log.d(TAG, "startNavigating");
      mStarted = true;
      int positionMode;
      if (Settings.Secure.getInt(
              mContext.getContentResolver(), Settings.Secure.ASSISTED_GPS_ENABLED, 1)
          != 0) {
        positionMode = GPS_POSITION_MODE_MS_BASED;
      } else {
        positionMode = GPS_POSITION_MODE_STANDALONE;
      }

      if (!native_start(positionMode, false, 1)) {
        mStarted = false;
        Log.e(TAG, "native_start failed in startNavigating()");
        return;
      }

      // reset SV count to zero
      updateStatus(LocationProvider.TEMPORARILY_UNAVAILABLE, 0);
      mFixCount = 0;
      mFixRequestTime = System.currentTimeMillis();
      // set timer to give up if we do not receive a fix within NO_FIX_TIMEOUT
      // and our fix interval is not short
      if (mFixInterval >= NO_FIX_TIMEOUT) {
        mAlarmManager.set(
            AlarmManager.ELAPSED_REALTIME_WAKEUP,
            SystemClock.elapsedRealtime() + NO_FIX_TIMEOUT * 1000,
            mTimeoutIntent);
      }
    }
  }
Esempio n. 18
0
  @Override
  public void processReceivedRecommendations() {
    displayRecommendations();

    if (!ClientAuthentication.getIfRecommendNotifyAdded()) {
      // add to notify
      ArrayList<FullTrip> recommendations = Storage.getRecommendations();

      int i = 1;

      for (FullTrip ft : recommendations) {
        Intent myIntent = new Intent(MainActivity.this, RecommendationAlarmReceiver.class);
        myIntent.setData(Uri.parse("timer:" + i));
        myIntent.putExtra("selectedTrip", ft);

        PendingIntent pendingIntent = PendingIntent.getBroadcast(MainActivity.this, 0, myIntent, 0);

        AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

        // notify the user half an hour before the beginning of the trip
        am.set(AlarmManager.RTC_WAKEUP, ft.getStartTime().getTime() - 1800000, pendingIntent);

        ClientAuthentication.setIfRecommendNotifyAdded(true);

        i++;
      }
    }
  }
Esempio n. 19
0
        public void onClick(View v) {
          AlarmManager mgr =
              (AlarmManager) AlarmActivity.this.getSystemService(Context.ALARM_SERVICE);
          Calendar cal = Calendar.getInstance();

          SharedPreferences prefs =
              PreferenceManager.getDefaultSharedPreferences(AlarmActivity.this);
          int snoozeLength = Integer.parseInt(prefs.getString("snooze_length", "10"));

          int minute = cal.get(Calendar.MINUTE);

          minute += snoozeLength;

          cal.set(Calendar.MINUTE, minute);

          Intent i = new Intent(AlarmActivity.this, OnAlarmReceiver.class);
          i.putExtra(OnBootReceiver.ID_EXTRA, "-1");
          PendingIntent pendInt = PendingIntent.getBroadcast(AlarmActivity.this, -1, i, 0);

          mgr.set(mgr.RTC_WAKEUP, cal.getTimeInMillis(), pendInt);

          // Should add a notification that can dismiss the pending snoozed alarm (id = -1)

          finish();
        }
Esempio n. 20
0
  /**
   * Sets alert in AlarmManger and StatusBar. This is what will actually launch the alert when the
   * alarm triggers.
   *
   * @param alarm Alarm.
   * @param atTimeInMillis milliseconds since epoch
   */
  private static void enableAlert(Context context, final Alarm alarm, final long atTimeInMillis) {
    AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);

    Intent intent = new Intent(ALARM_ALERT_ACTION);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    // XXX: This is a slight hack to avoid an exception in the remote
    // AlarmManagerService process. The AlarmManager adds extra data to
    // this Intent which causes it to inflate. Since the remote process
    // does not know about the Alarm class, it throws a
    // ClassNotFoundException.
    //
    // To avoid this, we marshall the data ourselves and then parcel a plain
    // byte[] array. The AlarmReceiver class knows to build the Alarm
    // object from the byte[] array.
    Parcel out = Parcel.obtain();
    alarm.writeToParcel(out, 0);
    out.setDataPosition(0);
    intent.putExtra(ALARM_RAW_DATA, out.marshall());
    PendingIntent sender =
        PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT);

    am.set(AlarmManager.RTC, atTimeInMillis, sender);

    // am.set(4, atTimeInMillis, sender);

    // setStatusBarIcon(context, true);

    Calendar c = Calendar.getInstance();
    c.setTimeInMillis(atTimeInMillis);
    String timeString = formatDayAndTime(context, c);
    saveNextAlarm(context, timeString);
  }
Esempio n. 21
0
    @Override
    public void run() {
      try {
        int warn = refreshData(_mContext);
        Intent broadcastIntent = new Intent(REFRESH_BROADCAST_MESSAGE);
        _mContext.sendBroadcast(broadcastIntent);

        if (warn > 0 && warn >= Preferences.getWarnLevel(_mContext)) {
          Notifier.showNotification(_mContext, warn);
        } else if (warn == ITerminal.STATE_OK) Notifier.hideNotification(_mContext, false);

        long interval = Preferences.getUpdateInterval(_mContext);
        if (interval == 0) return;
        AlarmManager alarmManager =
            (AlarmManager) _mContext.getSystemService(Context.ALARM_SERVICE);
        Intent startIntent = new Intent(_mContext, StatesReceiver.class);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(_mContext, 0, startIntent, 0);
        alarmManager.set(
            AlarmManager.ELAPSED_REALTIME_WAKEUP,
            SystemClock.elapsedRealtime() + interval,
            pendingIntent);
      } finally {
        _mWakeLock.release();
      }
    }
  /*
   * It is not the alarm that matters
   * but the pending intent.
   * Even with a repeating alarm for an intent,
   * if you schedule the same intent again
   * for one time, the later one takes affect.
   *
   * It is as if you are setting the
   * alarm on an existing intent multiple
   * times and not the other way around.
   */
  public void alarmIntentPrimacy() {
    Calendar cal = Utils.getTimeAfterInSecs(30);
    String s = Utils.getDateTimeString(cal);
    this.mReportTo.reportBack(
        tag, "Schdeduling Repeating alarm in 5 sec interval starting at: " + s);

    // Get an intent to invoke
    // TestReceiver class
    Intent intent = new Intent(this.mContext, TestReceiver.class);
    intent.putExtra("message", "Repeating Alarm");

    PendingIntent pi = getDistinctPendingIntent(intent, 0);
    AlarmManager am = (AlarmManager) this.mContext.getSystemService(Context.ALARM_SERVICE);

    this.mReportTo.reportBack(tag, "Setting a repeat alarm 5 secs duration");
    am.setRepeating(
        AlarmManager.RTC_WAKEUP,
        cal.getTimeInMillis(),
        5 * 1000, // 5 secs
        pi);

    this.mReportTo.reportBack(tag, "Setting a onetime alarm on the same intent");
    am.set(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), pi);
    this.mReportTo.reportBack(tag, "The later alarm, one time one, takes precedence");
  }
 public void setOnetimeTimer(Context context) {
   AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
   Intent intent = new Intent(context, AlarmBroadcastListener.class);
   intent.putExtra(ONE_TIME, Boolean.TRUE);
   PendingIntent pi = PendingIntent.getBroadcast(context, 0, intent, 0);
   am.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), pi);
 }
Esempio n. 24
0
 private void createMonitorAlarm() {
   AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
   Intent intent = new Intent(this, MonitoringAlarmReceiver.class);
   PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
   // the monitoring alarm will schedule another alarm once it's finished
   alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), pendingIntent);
 }
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    Log.i(TAG, "onStartCommand");

    // @TODO should test if startCommand is from autolaunch on boot -> then if yes, check if
    // CordovaStepCounter.ACTION_START has really been called or die
    Log.i(TAG, "- Relaunch service in 1 hour (4.4.2 start_sticky bug ) : ");
    Intent newServiceIntent = new Intent(this, StepCounterService.class);
    AlarmManager aManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    PendingIntent stepIntent =
        PendingIntent.getService(
            getApplicationContext(), 10, newServiceIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    // PendingIntent.GetService (ApplicationContext, 10, intent2, PendingIntentFlags.UpdateCurrent);

    aManager.set(
        AlarmManager.RTC, java.lang.System.currentTimeMillis() + 1000 * 60 * 60, stepIntent);

    if (isRunning /* || has no step sensors */) {
      Log.i(TAG, "Not initialising sensors");
      return Service.START_STICKY;
    }

    Log.i(TAG, "Initialising sensors");
    doInit();

    isRunning = true;
    return Service.START_STICKY;
  }
  private void setUpNewAlarm() {
    // get todays date
    Calendar cal = Calendar.getInstance();
    // get current month
    int currentMonth = cal.get(Calendar.MONTH);
    // move month ahead
    currentMonth++;
    // check if has not exceeded threshold of december
    if (currentMonth > Calendar.DECEMBER) {
      // alright, reset month to jan and forward year by 1 e.g fro 2013 to 2014
      currentMonth = Calendar.JANUARY;
      // Move year ahead as well
      cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 1);
    }
    // reset calendar to next month
    cal.set(Calendar.MONTH, currentMonth);

    // cal is set, now create new alarm for next month
    // Set intent to be broadcast for reminder
    Intent intent = new Intent(getApplicationContext(), OverheadReceiver.class);
    PendingIntent pendingIntent =
        PendingIntent.getBroadcast(
            getApplicationContext(),
            cal.get(Calendar.DAY_OF_MONTH),
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT);
    // Set AlarmManager to trigger broadcast
    AlarmManager alarmManager =
        (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
    alarmManager.set(AlarmManager.RTC, cal.getTimeInMillis(), pendingIntent);
  }
Esempio n. 27
0
  @Override
  public void onReceive(Context context, Intent intent) {

    Log.i("WifiO", "RecvTempDisable");

    LogWO logg = new LogWO(context);
    logg.log("WifiOpti Service disabled for 5m");

    SharedPreferences sett = context.getSharedPreferences("WifiOpti", 2);
    SharedPreferences.Editor settEditor = sett.edit();

    settEditor.putBoolean("WifiOptiServiced", false);
    settEditor.putBoolean("WifiOptiTempDisabled", true);
    settEditor.commit();

    // Turn off service
    Intent serviceIntent = new Intent(context, WifiOptiService.class);
    context.stopService(serviceIntent);

    // Schedule restart
    Intent alarmIntent = new Intent(context, RecvTempResume.class);
    AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, alarmIntent, 0);

    Calendar cal = Calendar.getInstance();
    cal.setTimeInMillis(System.currentTimeMillis());
    cal.add(Calendar.MINUTE, 5);

    Log.d("WifiO", " -> " + cal.getTime().toString());

    am.set(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), pendingIntent);
  }
Esempio n. 28
0
 /**
  * Run the notification service delayed by a minute to display and (re)schedule upcoming episode
  * alarms.
  */
 public static void runNotificationServiceDelayed(Context context) {
   AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
   Intent i = new Intent(context, OnAlarmReceiver.class);
   PendingIntent pi = PendingIntent.getBroadcast(context, 0, i, 0);
   am.set(
       AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + 1 * DateUtils.MINUTE_IN_MILLIS, pi);
 }
Esempio n. 29
0
  public void rescheduleFacebookUser(boolean force) {
    AlarmManager alarmMgr = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
    long nexttime;

    long current_time = System.currentTimeMillis();
    long last_update_time = orm.getLastUpdateFriendTime();
    long donespan = (current_time - last_update_time);
    long left_time = getFriendsTimeout() * 1000L - donespan;
    if (donespan < 0 || left_time <= 0) {
      long waittime = 1;
      for (int i = 0; i < nErrorCount && i < 10; i++) {
        waittime = waittime * 2;
      }
      nexttime = System.currentTimeMillis() + 10 * 1000 * waittime;
    } else {
      nexttime = System.currentTimeMillis() + left_time;
    }

    if (force == true) {
      nexttime = System.currentTimeMillis() + 10 * 1000;
    }

    if (SNSService.TEST_LOOP) {
      nexttime = System.currentTimeMillis() + 90 * 1000;
    }

    Intent i = new Intent();
    i.setClassName("com.ast.free", "com.ast.free.service.SNSService");
    i.setAction("com.ast.free.intent.action.FACEBOOK_USER");
    PendingIntent userpi =
        PendingIntent.getService(
            mContext.getApplicationContext(), 0, i, PendingIntent.FLAG_CANCEL_CURRENT);
    alarmMgr.set(AlarmManager.RTC_WAKEUP, nexttime, userpi);
  }
Esempio n. 30
0
  private void registerPongTimeout(long wait_time, String id) {
    pingID = id;
    pingTimestamp = System.currentTimeMillis();

    alarmManager.set(
        AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + wait_time, timeoutAlarmPendIntent);
  }