android/src/org/rockbox/RockboxService.java

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2010 Thomas Martitz
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 package org.rockbox;
  23
  24 import java.io.BufferedInputStream;
  25 import java.io.BufferedOutputStream;
  26 import java.io.File;
  27 import java.io.FileOutputStream;
  28 import java.util.Enumeration;
  29 import java.util.Timer;
  30 import java.util.TimerTask;
  31 import java.util.zip.ZipEntry;
  32 import java.util.zip.ZipFile;
  33
  34 import org.rockbox.Helper.MediaButtonReceiver;
  35 import org.rockbox.Helper.RunForegroundManager;
  36
  37 import android.app.Activity;
  38 import android.app.Service;
  39 import android.content.BroadcastReceiver;
  40 import android.content.Context;
  41 import android.content.Intent;
  42 import android.content.IntentFilter;
  43 import android.os.Bundle;
  44 import android.os.IBinder;
  45 import android.os.ResultReceiver;
  46 import android.util.Log;
  47 import android.view.KeyEvent;
  48
  49 /* This class is used as the main glue between java and c.
  50  * All access should be done through RockboxService.get_instance() for safety.
  51  */
  52
  53 public class RockboxService extends Service
  54 {
  55     /* this Service is really a singleton class - well almost.
  56      * To do it properly this line should be instance = new RockboxService()
  57      * but apparently that doesnt work with the way android Services are created.
  58      */
  59     private static RockboxService instance = null;
  60
  61     /* locals needed for the c code and rockbox state */
  62     private static volatile boolean rockbox_running;
  63     private Activity current_activity = null;
  64     private IntentFilter itf;
  65     private BroadcastReceiver batt_monitor;
  66     private RunForegroundManager fg_runner;
  67     private MediaButtonReceiver mMediaButtonReceiver;
  68     @SuppressWarnings("unused")
  69     private int battery_level;
  70     private ResultReceiver resultReceiver;
  71
  72     public static final int RESULT_INVOKING_MAIN = 0;
  73     public static final int RESULT_LIB_LOAD_PROGRESS = 1;
  74     public static final int RESULT_SERVICE_RUNNING = 3;
  75     public static final int RESULT_ERROR_OCCURED = 4;
  76     public static final int RESULT_LIB_LOADED = 5;
  77
  78     @Override
  79     public void onCreate()
  80     {
  81         instance = this;
  82         mMediaButtonReceiver = new MediaButtonReceiver(this);
  83         fg_runner = new RunForegroundManager(this);
  84     }
  85
  86     public static RockboxService get_instance()
  87     {
  88         /* don't call the construtor here, the instances are managed by
  89          * android, so we can't just create a new one */
  90         return instance;
  91     }
  92
  93     public boolean isRockboxRunning()
  94     {
  95         return rockbox_running;
  96     }
  97     public Activity get_activity()
  98     {
  99         return current_activity;
 100     }
 101     public void set_activity(Activity a)
 102     {
 103         current_activity = a;
 104     }
 105
 106     private void do_start(Intent intent)
 107     {
 108         LOG("Start RockboxService (Intent: " + intent.getAction() + ")");
 109         if (intent.hasExtra("callback"))
 110             resultReceiver = (ResultReceiver) intent.getParcelableExtra("callback");
 111
 112         if (!rockbox_running)
 113             startservice();
 114         if (resultReceiver != null)
 115             resultReceiver.send(RESULT_LIB_LOADED, null);
 116
 117         if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON))
 118         {
 119             /* give it a bit of time so we can register button presses
 120              * sleeping longer doesn't work here, apparently Android
 121              * surpresses long sleeps during intent handling */
 122             try {
 123                 Thread.sleep(50);
 124             } catch (InterruptedException e) { }
 125
 126             KeyEvent kev = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
 127             RockboxFramebuffer.buttonHandler(kev.getKeyCode(),
 128                                 kev.getAction() == KeyEvent.ACTION_DOWN);
 129         }
 130
 131         /* (Re-)attach the media button receiver, in case it has been lost */
 132         mMediaButtonReceiver.register();
 133         if (resultReceiver != null)
 134             resultReceiver.send(RESULT_SERVICE_RUNNING, null);
 135
 136         rockbox_running = true;
 137     }
 138
 139     private void LOG(CharSequence text)
 140     {
 141         Log.d("Rockbox", (String) text);
 142     }
 143
 144     private void LOG(CharSequence text, Throwable tr)
 145     {
 146         Log.d("Rockbox", (String) text, tr);
 147     }
 148
 149     public void onStart(Intent intent, int startId) {
 150         do_start(intent);
 151     }
 152
 153     public int onStartCommand(Intent intent, int flags, int startId)
 154     {
 155         do_start(intent);
 156         return 1; /* old API compatibility: 1 == START_STICKY */
 157     }
 158
 159     private void startservice()
 160     {
 161         final Object lock = new Object();
 162         Thread rb = new Thread(new Runnable()
 163         {
 164             public void run()
 165             {
 166                 final int BUFFER = 8*1024;
 167                 String rockboxDirPath = "/data/data/org.rockbox/app_rockbox/rockbox";
 168                 File rockboxDir = new File(rockboxDirPath);
 169
 170                 /* load library before unzipping which may take a while */
 171                 synchronized (lock) {
 172                     System.loadLibrary("rockbox");
 173                     lock.notify();
 174                 }
 175
 176                         /* the following block unzips libmisc.so, which contains the files
 177                          * we ship, such as themes. It's needed to put it into a .so file
 178                          * because there's no other way to ship files and have access
 179                          * to them from native code
 180                          */
 181                 File libMisc = new File("/data/data/org.rockbox/lib/libmisc.so");
 182                 /* use arbitrary file to determine whether extracting is needed */
 183                 File arbitraryFile = new File(rockboxDir, "viewers.config");
 184                 if (!arbitraryFile.exists() || (libMisc.lastModified() > arbitraryFile.lastModified()))
 185                 {
 186                         try
 187                         {
 188                         Bundle progressData = new Bundle();
 189                         byte data[] = new byte[BUFFER];
 190                         ZipFile zipfile = new ZipFile(libMisc);
 191                         Enumeration<? extends ZipEntry> e = zipfile.entries();
 192                         progressData.putInt("max", zipfile.size());
 193
 194                         while(e.hasMoreElements())
 195                         {
 196                            ZipEntry entry = (ZipEntry) e.nextElement();
 197                            File file;
 198                            /* strip off /.rockbox when extracting */
 199                            String fileName = entry.getName();
 200                            int slashIndex = fileName.indexOf('/', 1);
 201                            file = new File(rockboxDirPath + fileName.substring(slashIndex));
 202
 203                            if (!entry.isDirectory())
 204                            {
 205                                /* Create the parent folders if necessary */
 206                                File folder = new File(file.getParent());
 207                                if (!folder.exists())
 208                                    folder.mkdirs();
 209
 210                                /* Extract file */
 211                                BufferedInputStream is = new BufferedInputStream(zipfile.getInputStream(entry), BUFFER);
 212                                FileOutputStream fos = new FileOutputStream(file);
 213                                BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
 214
 215                                int count;
 216                                while ((count = is.read(data, 0, BUFFER)) != -1)
 217                                   dest.write(data, 0, count);
 218
 219                                dest.flush();
 220                                dest.close();
 221                                is.close();
 222                            }
 223
 224                            if (resultReceiver != null) {
 225                                progressData.putInt("value", progressData.getInt("value", 0) + 1);
 226                                resultReceiver.send(RESULT_LIB_LOAD_PROGRESS, progressData);
 227                            }
 228                         }
 229                         } catch(Exception e) {
 230                             LOG("Exception when unzipping", e);
 231                             e.printStackTrace();
 232                             if (resultReceiver != null) {
 233                                 Bundle bundle = new Bundle();
 234                             bundle.putString("error", getString(R.string.error_extraction));
 235                                 resultReceiver.send(RESULT_ERROR_OCCURED, bundle);
 236                             }
 237                         }
 238                 }
 239
 240                         if (resultReceiver != null)
 241                             resultReceiver.send(RESULT_INVOKING_MAIN, null);
 242
 243                 main();
 244                         throw new IllegalStateException("native main() returned!");
 245             }
 246         }, "Rockbox thread");
 247         rb.setDaemon(false);
 248         /* wait at least until the library is loaded */
 249         synchronized (lock)
 250         {
 251             rb.start();
 252             while(true)
 253             {
 254                 try {
 255                     lock.wait();
 256                 } catch (InterruptedException e) {
 257                     continue;
 258                 }
 259                 break;
 260             }
 261         }
 262     }
 263
 264     private native void main();
 265
 266     @Override
 267     public IBinder onBind(Intent intent)
 268     {
 269         // TODO Auto-generated method stub
 270         return null;
 271     }
 272
 273
 274     @SuppressWarnings("unused")
 275     /*
 276      * Sets up the battery monitor which receives the battery level
 277      * about each 30 seconds
 278      */
 279     private void initBatteryMonitor()
 280     {
 281         itf = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
 282         batt_monitor = new BroadcastReceiver()
 283         {
 284             @Override
 285             public void onReceive(Context context, Intent intent)
 286             {
 287                 /* we get literally spammed with battery statuses
 288                  * if we don't delay the re-attaching
 289                  */
 290                 TimerTask tk = new TimerTask()
 291                 {
 292                     public void run()
 293                     {
 294                         registerReceiver(batt_monitor, itf);
 295                     }
 296                 };
 297                 Timer t = new Timer();
 298                 context.unregisterReceiver(this);
 299                 int rawlevel = intent.getIntExtra("level", -1);
 300                 int scale = intent.getIntExtra("scale", -1);
 301                 if (rawlevel >= 0 && scale > 0)
 302                     battery_level = (rawlevel * 100) / scale;
 303                 else
 304                     battery_level = -1;
 305                 /* query every 30s should be sufficient */
 306                 t.schedule(tk, 30000);
 307             }
 308         };
 309         registerReceiver(batt_monitor, itf);
 310     }
 311
 312     public void startForeground()
 313     {
 314         fg_runner.startForeground();
 315     }
 316
 317     public void stopForeground()
 318     {
 319         fg_runner.stopForeground();
 320     }
 321
 322     @Override
 323     public void onDestroy()
 324     {
 325         super.onDestroy();
 326         mMediaButtonReceiver.unregister();
 327         mMediaButtonReceiver = null;
 328         /* Make sure our notification is gone. */
 329         stopForeground();
 330         instance = null;
 331         rockbox_running = false;
 332     }
 333 }