android/src/org/rockbox/Helper/RunForegroundManager.java

   1 package org.rockbox.Helper;
   2
   3 import java.lang.reflect.InvocationTargetException;
   4 import java.lang.reflect.Method;
   5
   6 import org.rockbox.R;
   7 import org.rockbox.RockboxActivity;
   8
   9 import android.app.Notification;
  10 import android.app.NotificationManager;
  11 import android.app.PendingIntent;
  12 import android.app.Service;
  13 import android.content.Intent;
  14 import android.util.Log;
  15 import android.widget.RemoteViews;
  16
  17 public class RunForegroundManager
  18 {
  19     /* all below is heavily based on the examples found on
  20      * http://developer.android.com/reference/android/app/Service.html#setForeground(boolean)
  21      */
  22     private Notification mNotification;
  23     private NotificationManager mNM;
  24     private IRunForeground api;
  25     private Service mCurrentService;
  26
  27     public RunForegroundManager(Service service) throws Exception
  28     {
  29         mCurrentService = service;
  30         mNM = (NotificationManager)
  31                         service.getSystemService(Service.NOTIFICATION_SERVICE);
  32         RemoteViews views = new RemoteViews(service.getPackageName(), R.layout.statusbar);
  33         /* create Intent for clicking on the expanded notifcation area */
  34         Intent intent = new Intent(service, RockboxActivity.class);
  35         intent = intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  36
  37         mNotification = new Notification();
  38         mNotification.tickerText = service.getString(R.string.notification);
  39         mNotification.icon = R.drawable.notification;
  40         mNotification.contentView = views;
  41         mNotification.flags |= Notification.FLAG_ONGOING_EVENT;
  42         mNotification.contentIntent = PendingIntent.getActivity(service, 0, intent, 0);
  43
  44         try {
  45             api = new newForegroundApi(R.string.notification, mNotification);
  46         } catch (NoSuchMethodException e) {
  47             /* Fall back on the old API */
  48             api = new oldForegroundApi();
  49         }
  50     }
  51     private void LOG(CharSequence text)
  52     {
  53         Log.d("Rockbox", (String)text);
  54     }
  55     private void LOG(CharSequence text, Throwable tr)
  56     {
  57         Log.d("Rockbox", (String)text, tr);
  58     }
  59
  60     public void startForeground()
  61     {
  62         /*
  63          * Send the notification.
  64          * We use a layout id because it is a unique number.
  65          * We use it later to cancel.
  66          */
  67         mNM.notify(R.string.notification, mNotification);
  68         /*
  69          * this call makes the service run as foreground, which
  70          * provides enough cpu time to do music decoding in the
  71          * background
  72          */
  73         api.startForeground();
  74     }
  75
  76     public void stopForeground()
  77     {
  78         /* Note to cancel BEFORE changing the
  79          * foreground state, since we could be killed at that point.
  80          */
  81         mNM.cancel(R.string.notification);
  82         api.stopForeground();
  83     }
  84
  85     public void updateNotification(String title, String artist, String album)
  86     {
  87         RemoteViews views = mNotification.contentView;
  88         views.setTextViewText(R.id.title, title);
  89         views.setTextViewText(R.id.content, artist+"\n"+album);
  90         if (artist.equals(""))
  91             mNotification.tickerText = title;
  92         else
  93             mNotification.tickerText = title+" - "+artist;
  94         mNM.notify(R.string.notification, mNotification);
  95     }
  96
  97     private interface IRunForeground
  98     {
  99         void startForeground();
 100         void stopForeground();
 101     }
 102
 103     private class newForegroundApi implements IRunForeground
 104     {
 105         Class<?>[] mStartForegroundSignature =
 106             new Class[] { int.class, Notification.class };
 107         Class<?>[] mStopForegroundSignature =
 108             new Class[] { boolean.class };
 109         private Method mStartForeground;
 110         private Method mStopForeground;
 111         private Object[] mStartForegroundArgs = new Object[2];
 112         private Object[] mStopForegroundArgs = new Object[1];
 113
 114         newForegroundApi(int id, Notification notification)
 115             throws SecurityException, NoSuchMethodException
 116         {
 117             /*
 118              * Get the new API through reflection
 119              */
 120             mStartForeground = Service.class.getMethod("startForeground",
 121                     mStartForegroundSignature);
 122             mStopForeground = Service.class.getMethod("stopForeground",
 123                     mStopForegroundSignature);
 124             mStartForegroundArgs[0] = id;
 125             mStartForegroundArgs[1] = notification;
 126             mStopForegroundArgs[0] = Boolean.TRUE;
 127         }
 128
 129         public void startForeground()
 130         {
 131             try {
 132                 mStartForeground.invoke(mCurrentService, mStartForegroundArgs);
 133             } catch (InvocationTargetException e) {
 134                 /* Should not happen. */
 135                 LOG("Unable to invoke startForeground", e);
 136             } catch (IllegalAccessException e) {
 137                 /* Should not happen. */
 138                 LOG("Unable to invoke startForeground", e);
 139             }
 140         }
 141
 142         public void stopForeground()
 143         {
 144             try {
 145                 mStopForeground.invoke(mCurrentService, mStopForegroundArgs);
 146             } catch (InvocationTargetException e) {
 147                 /* Should not happen. */
 148                 LOG("Unable to invoke stopForeground", e);
 149             } catch (IllegalAccessException e) {
 150                 /* Should not happen. */
 151                 LOG("Unable to invoke stopForeground", e);
 152             }
 153         }
 154     }
 155
 156     private class oldForegroundApi implements IRunForeground
 157     {
 158         public void startForeground()
 159         {
 160             mCurrentService.setForeground(false);
 161         }
 162         public void stopForeground()
 163         {
 164             mCurrentService.setForeground(false);
 165         }
 166     }
 167 }