So erstellen Sie persistente Alarme auch nach dem Neustart

Question

Momentan arbeite ich an einer App, die wie "Aufgabenliste" funktioniert. Ich habe den NotificationService und den SchedularService in meiner Anwendung erfolgreich implementiert. Außerdem erhalte ich die Benachrichtigungen (Benachrichtigungen) zu der für die Aufgaben festgelegten Zeit. Hier sind meine Fragen wie folgt:

1. Mit diesem Code werden meine Alarme nach dem Neustart gelöscht werden? Wenn ja, wie überwinde ich das?
2. Ich habe die Prioritätsfunktion für die Aufgaben behalten. Aber ich möchte den Mechanismus so, dass, wenn der Benutzer die Priorität "Hoch" wählt, er Benachrichtigungen dreimal erhalten sollte, sagen wir vor 30 Minuten, vor 15 Minuten und nach der eingestellten Zeit. Wie erreiche ich das?
3. Ich möchte die Vibrationsfunktion des Telefons einstellen, wenn Benachrichtigungen ausgelöst werden. Wie erreiche ich das?
4. Und ich möchte wissen, was für die veralteten Methoden und Konstruktor in NotifyService.java getan werden kann. Dies ist in der API-Stufe 11: Notification notification = new Notification(icon, text, time); und notification.setLatestEventInfo(this, title, text, contentIntent); veraltet. Auf developer.android.com haben sie stattdessen vorgeschlagen, Notification.Builder zu verwenden. So, wie ich meine App mit allen API-Ebenen kompatibel machen kann.

Hier ist mein Snippet-Code für die Planung Alarm:

... 
scheduleClient.setAlarmForNotification(c, tmp_task_id); 
... 

Hier ist die Klasse ScheduleClient.java:

public class ScheduleClient { 

    private ScheduleService mBoundService; 
    private Context mContext; 
    private boolean mIsBound; 

    public ScheduleClient(Context context) 
    { 
     mContext = context; 
    } 

    public void doBindService() 
    { 
     mContext.bindService(new Intent(mContext, ScheduleService.class), mConnection, Context.BIND_AUTO_CREATE); 
     mIsBound = true; 
    } 

    private ServiceConnection mConnection = new ServiceConnection() { 
     public void onServiceConnected(ComponentName className, IBinder service) { 

      mBoundService = ((ScheduleService.ServiceBinder) service).getService(); 
     } 

     public void onServiceDisconnected(ComponentName className) { 

      mBoundService = null; 
     } 
    }; 

    public void setAlarmForNotification(Calendar c, int tmp_task_id){ 

     mBoundService.setAlarm(c, tmp_task_id); 
    } 

    public void doUnbindService() { 
     if (mIsBound) 
     {   
      mContext.unbindService(mConnection); 
      mIsBound = false; 
     } 
    } 
} 

Hier ist die ScheduleService.java:

public class ScheduleService extends Service { 

    int task_id; 

    public class ServiceBinder extends Binder { 

     ScheduleService getService() { 

      return ScheduleService.this; 
     } 
    } 

    @Override 
    public int onStartCommand(Intent intent, int flags, int startId) { 

     return START_STICKY; 
    } 

    @Override 
    public IBinder onBind(Intent intent) { 

     return mBinder; 
    } 

    private final IBinder mBinder = new ServiceBinder(); 

    public void setAlarm(Calendar c, int tmp_task_id) { 

     new AlarmTask(this, c, tmp_task_id).run(); 
    } 
} 

Hier ist die AlarmTask.java:

public class AlarmTask implements Runnable{ 

    private final Calendar date; 
    private final AlarmManager am; 
    private final Context context; 
    int task_id; 

    public AlarmTask(Context context, Calendar date, int tmp_task_id) { 
     this.context = context; 
     this.am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); 
     this.date = date; 

     task_id = tmp_task_id; 
    } 

    @Override 
    public void run() { 

     Intent intent = new Intent(context, NotifyService.class); 
     intent.putExtra(NotifyService.INTENT_NOTIFY, true); 
     intent.putExtra("task_id", task_id); 
     PendingIntent pendingIntent = PendingIntent.getService(context, 0, intent, 0); 

     am.set(AlarmManager.RTC, date.getTimeInMillis(), pendingIntent); 
    } 
} 

Hier ist der NotifyService.java:

public class NotifyService extends Service { 

    public class ServiceBinder extends Binder 
    { 
     NotifyService getService() 
     { 
      return NotifyService.this; 
     } 
    } 

    int task_id; 
    private static final int NOTIFICATION = 123; 
    public static final String INTENT_NOTIFY = "com.todotaskmanager.service.INTENT_NOTIFY"; 
    private NotificationManager mNM; 
    SQLiteDatabase database; 

    @Override 
    public void onCreate() { 

     mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); 
    } 

    @Override 
    public int onStartCommand(Intent intent, int flags, int startId) { 

     String tmp_task_brief = null; 
     task_id = intent.getIntExtra("task_id", 0); 

     loadDatabase(); 
     Cursor cursor = database.query("task_info", new String[]{"task_brief"}, "task_id=?", new String[]{task_id+""}, null, null, null); 
     while(cursor.moveToNext()) 
     { 
      tmp_task_brief = cursor.getString(0); 
     } 
     cursor.close(); 

     if(intent.getBooleanExtra(INTENT_NOTIFY, false)) 
      showNotification(tmp_task_brief); 

     return START_NOT_STICKY; 
    } 

    @Override 
    public IBinder onBind(Intent intent) { 

     return mBinder; 
    } 

    private final IBinder mBinder = new ServiceBinder(); 

    private void showNotification(String tmp_task_brief) { 

     CharSequence title = "To Do Task Notification!!"; 
     int icon = R.drawable.e7ca62cff1c58b6709941e51825e738f; 
     CharSequence text = tmp_task_brief;  
     long time = System.currentTimeMillis(); 

     Notification notification = new Notification(icon, text, time); 

     PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, TaskDetails.class), 0); 

     notification.setLatestEventInfo(this, title, text, contentIntent); 

     notification.flags |= Notification.FLAG_AUTO_CANCEL; 

     mNM.notify(NOTIFICATION, notification); 

     stopSelf(); 
    } 

    void loadDatabase() 
    { 
     database = openOrCreateDatabase("ToDoDatabase.db", 
       SQLiteDatabase.OPEN_READWRITE, null); 
    } 
} 

Answer 1

Mit diesem Code wird mein Alarm nach einem Neustart gelöscht werden? Wenn ja, wie überwinde ich das?

Ja Alarm erhalten gelöscht wird, dies zu überwinden, müssen Sie BroadcastReceiver namens Android Komponente wie folgt verwenden,

Zuerst müssen Sie die Berechtigung in Ihrem Manifest:

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> 

Auch Definieren Sie in Ihrem Manifest Ihren Dienst und warten Sie auf die Aktion boot-excluded:

<receiver 
    android:name=".receiver.StartMyServiceAtBootReceiver" 
    android:enabled="true" 
    android:exported="true" 
    android:label="StartMyServiceAtBootReceiver"> 
    <intent-filter> 
     <action android:name="android.intent.action.BOOT_COMPLETED" /> 
    </intent-filter> 
</receiver> 

Dann müssen Sie d efine den Empfänger, der die Aktion BOOT_COMPLETED erhält und Ihren Dienst startet.

public class StartMyServiceAtBootReceiver extends BroadcastReceiver { 

    @Override 
    public void onReceive(Context context, Intent intent) { 
     if ("android.intent.action.BOOT_COMPLETED".equals(intent.getAction())) { 
      Intent serviceIntent = new Intent("com.myapp.NotifyService"); 
      context.startService(serviceIntent); 
     } 
    } 
} 

Und jetzt sollte Ihr Dienst ausgeführt werden, wenn das Telefon startet.

2 zur Schwingungs

Wieder benötigen Sie eine Erlaubnis in AndroidManifest.xml Datei wie folgt zu definieren,

<uses-permission android:name="android.permission.VIBRATE"/> 

Hier ist der Code für Vibration,

// Get instance of Vibrator from current Context 
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); 

// Vibrate for 300 milliseconds 
v.vibrate(300);