Korrigieren Sie das Muster, um einen WakeLock in einem BroadcastReceiver zu erwerben und in einem Service freizugeben

Auch nach viel recherche bin ich noch nicht ganz sicher, ob die Art und Weise, wie implementiere ich eine WakeLock für eine Service begann mit einem BroadcastReceiver korrekt ist - auch wenn es scheint gut zu funktionieren. Der broadcast receiver bekommt Absichten geschickt, um es von einem alarm, so mit zu beginnen, aus den API-docs AlarmManager:

Wenn Ihr alarm-Empfänger namens Kontext.startService(), ist es möglich
dass das Telefon zu schlafen, bevor der angeforderte Dienst ist gestartet. Zu
dies zu verhindern, Ihre BroadcastReceiver und Service müssen
die Implementierung einer eigenen wake-lock-Politik, um sicherzustellen, dass das Telefon
weiterhin ausgeführt, bis der Dienst verfügbar ist.

So, in onReceive() ich tun:

    Intent serviceIntent = new Intent(context, SomeService.class);
    context.startService(serviceIntent);

    if(SomeService.wakeLock == null) {
        PowerManager powerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
        SomeService.wakeLock = powerManager.newWakeLock(
                PowerManager.PARTIAL_WAKE_LOCK, 
                SomeService.WAKE_LOCK_TAG);
    }
    if(! SomeService.wakeLock.isHeld()) {
        SomeService.wakeLock.acquire();
    }

- und service ich:

    try {
        //Do some work
    } finally {
        if(wakeLock != null) {
            if(wakeLock.isHeld()) {
                wakeLock.release();
            }
            wakeLock = null;
        }
    }

Den SomeService.wakeLockFeld Paket private, static-und volatile.

Was ich bin nicht sicher ist die Prüfung mit isHeld() - muss es wirklich sagen Sie mir, wenn ein WakeLock erworben wird oder nicht, und brauche ich, wenn ich diese Prüfung überhaupt?

InformationsquelleAutor der Frage Torsten Römer | 2011-08-24

4

Was ich bin nicht sicher ist die Prüfung mit isHeld() - muss es wirklich sagen Sie mir, wenn ein WakeLock erworben wird oder nicht, und brauche ich, wenn ich diese Prüfung überhaupt?

Tatsächlich etwas schwierig zu beantworten. Suche an der Quelle für PowerManager und PowerManager.WakeLock hier die WakeLock.acquire() und WakeLock.acquireLocked() Methoden sind wie folgt...
```
public void acquire(long timeout) {
    synchronized (mToken) {
        acquireLocked();
        mHandler.postDelayed(mReleaser, timeout);
    }
}

private void acquireLocked() {
    if (!mRefCounted || mCount++ == 0) {
        //Do this even if the wake lock is already thought to be held (mHeld == true)
        //because non-reference counted wake locks are not always properly released.
        //For example, the keyguard's wake lock might be forcibly released by the
        //power manager without the keyguard knowing.  A subsequent call to acquire
        //should immediately acquire the wake lock once again despite never having
        //been explicitly released by the keyguard.
        mHandler.removeCallbacks(mReleaser);
        try {
            mService.acquireWakeLock(mToken, mFlags, mTag, mWorkSource);
        } catch (RemoteException e) {
        }
        mHeld = true;
    }
}
```
...mService ist ein IPowerManager - Schnittstelle und die Quelle ist nicht verfügbar, so ist es schwer zu sagen, was kann oder kann nicht schief gehen, wenn Sie versuchen, um call acquireWakeLock(...).

In jedem Fall, die einzige Ausnahme, die gefangen werden können, ist RemoteException und die catch blockieren tut nichts. Sofort nach dem try - /catch - mHeld eingestellt ist true unabhängig.

Kurz gesagt, wenn Sie anrufen isHeld() sofort nach acquire() ist das Ergebnis immer true.

Suchen weiter in der Quelle für PowerManager.WakeLock zeigt ein ähnliches Verhalten für release() fordert release(int flags) wo die mHeld Mitglied immer auf false egal, was passiert.

Abschließend würde ich vorschlagen, es ist immer eine gute Idee zu überprüfen isHeld() nur als "best practice" in späteren Versionen von Android ändern Sie dieses Verhalten der WakeLock Methoden.

InformationsquelleAutor der Antwort Squonk

Verwalten Sie wakeLock innerhalb einer singleton (eindeutige Instanz zugänglich durch alle Ihre Kontext-und Objekt -)

Einsatz einer singleton-Instanz einer benutzerdefinierten Klasse, dann erhalten Sie möglicherweise wakelock-Objekt-Referenz aufrufen ,

hier ein singleton-Beispiel

class MyData {
   private static MyData mMydata= null; //unique reference ( singleton objet container)

   private PowerManager.Wakelock myobject = null; //inside the unique object container we have the unique working object to be use  by the application
   //can't make instance from outside... we want to have single instance
   //we want that outside use method "getInstance" to be able to use the object
   private MyData() {
   }

   //retrieve and/or create new unique instance
   public static MyData getInstance() {
     if (mMydata ==  null) mMyData = new MyData();
     return   mMyData;
   }

   //Works with your memory stored object
   //get...
   public PowerManager.WakeLock getMyWakelock() {
   return myobject;
   }
   //set ...
   public void setMyWakeLock(PowerManager.WakeLock obj) {
    myobject = obj;
   }
}

in Ihrer Anwendung, um Ihre "wakelock" - Objekt zugreifen können, wie

//set a created wakelock
MyData.getInstance().setMyWakeLock(wl);
//get the saved wakelock object
PowerManager.WakeLock obj =  MyData.getInstance().getMyWakeLock();

InformationsquelleAutor der Antwort Emmanuel Devaux

3

Alle dieser job kann getan werden, indem ein Helfer und native Klasse namens WakefulBroadcastReceiver

InformationsquelleAutor der Antwort CelinHC

Ich denke android.os.Messenger kann einen besseren Weg

für den Empfänger:

public class MessengerReceiver extends BroadcastReceiver {


    private static final String TAG = "MessengerReceiver";

    private final MessengerHandler mHandler = new MessengerHandler();

    @Override
    public void onReceive(Context context, Intent intent) {
        //TODO: This method is called when the BroadcastReceiver is receiving
        //an Intent broadcast.
        mHandler.mWakeLock = ((PowerManager)context.getSystemService(Service.POWER_SERVICE)).newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "myreceiver");
        mHandler.mWakeLock.acquire();
        Log.e(TAG, "onReceive:: mHandler.mWakeLock=" + mHandler.mWakeLock + ", intent=" + intent + ", this=" + this);
        context.startService(new Intent(context, MessengerService.class).putExtra("messenger", new Messenger(mHandler)));
    }

    static class MessengerHandler extends Handler {

        WakeLock mWakeLock;
        @Override
        public void handleMessage(Message msg) {
            //TODO Auto-generated method stub
            if(mWakeLock != null){
                mWakeLock.release();
                Log.e(TAG, "handleMessage:mWakeLock=" + mWakeLock);
            }
            super.handleMessage(msg);
        }

    }
}

für den service:

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    public MessengerService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        //TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //TODO Auto-generated method stub      
        Log.e(TAG, "onStartCommand:: intent=" + intent);
        final Messenger messenger = intent.getParcelableExtra("messenger");
        try {
            messenger.send(Message.obtain());
        } catch (RemoteException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
        return super.onStartCommand(intent, flags, startId);
    }
}

Diese Methode funktioniert ordnungsgemäß, auch wenn service & receiver laufen in verschiedenen Verfahren.

InformationsquelleAutor der Antwort Yessy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.