Come creare allarmi persistenti anche dopo il riavvio

Question

Attualmente, sto lavorando su app che funziona come "Elenco attività da fare". Ho implementato con successo NotificationService e SchedularService nella mia applicazione. Inoltre ricevo gli avvisi (Notifiche) all'ora impostata per le attività. Ecco le mie domande come di seguito:

1. Con questo codice i miei allarmi verranno eliminati dopo il riavvio? Se sì, come superare questo.
2. Ho mantenuto la funzione Priorità per le attività. Ma io voglio il meccanismo in modo tale che se l'utente seleziona la priorità "Alta", allora dovrebbe ricevere le notifiche tre volte, per esempio, prima di 30 minuti, prima di 15 minuti e all'orario impostato. Come ottenere questo?
3. Desidero impostare la funzione di vibrazione del telefono quando vengono generate le notifiche. Come ottenere questo?
4. E voglio sapere, cosa si può fare per i metodi e il costruttore deprecati in NotifyService.java. Thesse sono deprecati al livello API 11: Notification notification = new Notification(icon, text, time); e notification.setLatestEventInfo(this, title, text, contentIntent);. Su developer.android.com, hanno suggerito di utilizzare Notification.Builder invece. Quindi, come rendere la mia app compatibile con tutti i livelli API.

Ecco il mio frammento di codice per l'allarme di schedulazione:

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

Ecco lo ScheduleClient.java classe:

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; 
     } 
    } 
} 

Ecco lo 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(); 
    } 
} 

Ecco il 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); 
    } 
} 

Ecco il 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

Con questo codice saranno i miei allarmi saranno cancellati dopo il riavvio? Se sì, come superare questo.

Sì allarme vengono eliminati, per ovviare a questo, è necessario utilizzare componenti di Android chiamato BroadcastReceiver come segue,

In primo luogo, è necessario il permesso nel vostro manifesto:

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

Inoltre, nel tuo manifest, definisci il tuo servizio e ascolta l'azione completata:

<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> 

Quindi devi perfezionare il ricevitore che otterrà l'azione BOOT_COMPLETED e avvierà il servizio.

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); 
     } 
    } 
} 

E ora il servizio dovrebbe essere in esecuzione all'avvio del telefono.

2 Per le vibrazioni trasmesse

Anche in questo caso è necessario definire un permesso nel file di AndroidManifest.xml come segue,

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

Ecco il codice per la vibrazione,

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

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