Lassen Sie eine lokale Benachrichtigung jeden Tag zu einer bestimmten Zeit, auch wenn die App geschlossen ist

Question

Ich muss eine Benachrichtigung jeden Tag zu einer bestimmten Zeit (sagen 7.00 Uhr) für die Benutzer von meiner App auch wenn meine App nicht ausgeführt wurde . (geschlossen)

Als Inhalt der Mitteilung benutzerspezifische sein wird, kann ich nicht (GCM) verwenden schieben

ich habe durch viele Tutorials und Antworten gegangen, aber ich kann nicht der Lage Benachrichtigung angezeigt werden wenn die App geschlossen ist (nicht ausgeführt).

Edit: Mit dem folgenden Code ich in der Lage bin, eine Benachrichtigung zu erstellen, während meine Anwendung läuft, wenn ich meine App-Benachrichtigungen in der Nähe zeigt sich

Hier ist meine Haupttätigkeit

public class MainActivity extends AppCompatActivity { 
Button setAlarm; 

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

    setAlarm = (Button) findViewById(R.id.set_alarm); 
    setAlarm.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      NotificationEventReceiver.setupAlarm(getApplicationContext()); 
     } 
    }); 
} 
@Override 
protected void onNewIntent(Intent intent) { 
    super.onNewIntent(intent); 
    setIntent(intent); 
} 
} 

hier, wenn ich auf die eingestellte Alarmtaste meine NotificationEventReciver rufen

public class NotificationEventReceiver extends WakefulBroadcastReceiver { 
private static final String ACTION_START_NOTIFICATION_SERVICE = "ACTION_START_NOTIFICATION_SERVICE"; 
private static final String ACTION_DELETE_NOTIFICATION = "ACTION_DELETE_NOTIFICATION"; 


public static void setupAlarm(Context context) { 
    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); 
    Intent intent = new Intent(context, NotificationEventReceiver.class); 
    PendingIntent alarmIntent = PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
    alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, getTriggerAt(new Date()), 2 * 60 * 1000, alarmIntent); 

} 
private static long getTriggerAt(Date now) { 
    Calendar calendar = Calendar.getInstance(); 
    calendar.setTimeInMillis(System.currentTimeMillis()); 
    calendar.set(Calendar.HOUR_OF_DAY, 17); 
    calendar.set(Calendar.MINUTE, 10); 
    System.err.println(now.getTime()+"----->"+ calendar.getTimeInMillis()); 
    return calendar.getTimeInMillis(); 
} 

public static void cancelAlarm(Context context) { 
    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); 
    PendingIntent alarmIntent = getStartPendingIntent(context); 
    alarmManager.cancel(alarmIntent); 
} 


private static PendingIntent getStartPendingIntent(Context context) { 
    Intent intent = new Intent(context, NotificationEventReceiver.class); 
    intent.setAction(ACTION_START_NOTIFICATION_SERVICE); 
    return PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
} 

public static PendingIntent getDeleteIntent(Context context) { 
    Intent intent = new Intent(context, NotificationEventReceiver.class); 
    intent.setAction(ACTION_DELETE_NOTIFICATION); 
    return PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
} 

@Override 
public void onReceive(Context context, Intent intent) { 
    Intent serviceIntent = NotificationIntentService.createIntentStartNotificationService(context); 
    if (serviceIntent != null) { 
     System.err.println("onReceive inside not null"); 
     // Start the service, keeping the device awake while it is launching. 
     startWakefulService(context, serviceIntent); 
    } 
} 
} 

Meine Serviceklasse, die ausgeführt wird, wenn der Alarm ausgeht.

public class NotificationIntentService extends IntentService { 

private static final int NOTIFICATION_ID = 1; 
private static final String ACTION_START = "ACTION_START"; 
private static final String ACTION_DELETE = "ACTION_DELETE"; 

public NotificationIntentService() { 
    super(NotificationIntentService.class.getSimpleName()); 
} 

public static Intent createIntentStartNotificationService(Context context) { 
    Intent intent = new Intent(context, NotificationIntentService.class); 
    intent.setAction(ACTION_START); 
    return intent; 
} 

@Override 
protected void onHandleIntent(Intent intent) { 
    System.err.println("onHandleIntent, started handling a notification event"); 
    try { 
     String action = intent.getAction(); 
     if (ACTION_START.equals(action)) { 
      System.err.println("enters the loop ACTION_START"); 
      processStartNotification(); 
     } 
    } finally { 
     WakefulBroadcastReceiver.completeWakefulIntent(intent); 
    } 
} 


private void processStartNotification() { 
    // Do something. For example, fetch fresh data from backend to create a rich notification? 
    System.err.println("inside the notify method"); 
    Intent mainIntent = new Intent(this, MainActivity.class); 
    PendingIntent pendingIntent = PendingIntent.getActivity(this, NOTIFICATION_ID, mainIntent, PendingIntent.FLAG_UPDATE_CURRENT); 

    final NotificationCompat.Builder builder = new NotificationCompat.Builder(this); 
    builder.setContentTitle("Scheduled Notification") 
      .setAutoCancel(true) 
      .setColor(getResources().getColor(R.color.colorAccent)) 
      .setContentText("This notification has been triggered by Notification Service") 
      .setSmallIcon(R.drawable.ic_launcher); 

    builder.setContentIntent(pendingIntent); 

    final NotificationManager manager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE); 
    manager.notify(NOTIFICATION_ID, builder.build()); 
} 
} 

Answer 1

Versuchen Sie dies in Ihrem setUpAlarm Methoden-

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

Intent intent = new Intent(cont, MyReceiver.class);  
intent.setAction(MyReceiver.ACTION_ALARM_RECEIVER); 

boolean isWorking = (PendingIntent.getBroadcast(cont, 1001, 

    intent, PendingIntent.FLAG_NO_CREATE) != null); 
    if (isWorking) { 
    // first cancel previous alarm 
    Intent intent = new Intent(cont, MyReceiver.class);// the same as up 
    intent.setAction(MyReceiver.ACTION_ALARM_RECEIVER);// the same as up 
    PendingIntent pI = PendingIntent.getBroadcast(cont, 1001, 
    intent, PendingIntent.FLAG_CANCEL_CURRENT);// the same as up 
    am.cancel(pI);// important 
    pI.cancel();// important 
    } else { 
    Intent intent1 = new Intent(cont, MyReceiver.class); 
    intent1.setAction(MyReceiver.ACTION_ALARM_RECEIVER); 

    PendingIntent pendingIntent = PendingIntent 
    .getBroadcast(cont, 0, intent1, 
    PendingIntent.FLAG_UPDATE_CURRENT); 
    AlarmManager am = (AlarmManager) cont 
    .getSystemService(cont.ALARM_SERVICE); 

    am.setRepeating(AlarmManager.RTC_WAKEUP, 
    calendar.getTimeInMillis(), 
    AlarmManager.INTERVAL_DAY, pendingIntent); 
    } 

hoffe, das hilft! :)