2011-04-12 5 views
13

Estoy trabajando en el control parental/aplicación de filtrado de contenido para adultos. Esta aplicación monitorea continuamente las llamadas y sms en el móvil de un niño y registra toda la actividad en un servidor. Para esto estoy comenzando un servicio (MyService.java) en BOOT_COMPLETED y en el método onCreate del servicio, registro un contentobserver para callLog y sms uri (consulte el fragmento de código a continuación).Registrar un ContentObserver en un servicio de Android

Ahora el problema es que, dado que quiero monitorear todas las llamadas entrantes y salientes s y sms, quiero que el servicio se ejecute continuamente (sin detenerse ni cancelarse). Además, este servicio se está utilizando para registrar observadores de contenido y no realizar ningún otro procesamiento (su método OnstartCommand es ficticio), por lo que el sistema operativo Android mata el servicio después de algún tiempo. ¿Cómo me aseguro de que el servicio se ejecute continuamente y mantenga vivo el objeto contentobserver?

 
public class MyService extends Service { 

    private CallLogObserver clLogObs = null; 
    public void onCreate() {   
     super.onCreate();  
     try{        
      clLogObs = new CallLogObserver(this); 
      this.getContentResolver().registerContentObserver(android.provider.CallLog.Calls.CONTENT_URI, true, clLogObs);    
     }catch(Exception ex) 
     { 
      Log.e("CallLogData", ex.toString()); 
     } 
    } 

    @Override 
    public IBinder onBind(Intent arg0) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public void onDestroy() { 
     if(clLogObs !=null ) 
     { 
      this.getContentResolver().unregisterContentObserver(clLogObs); 
     } 
     super.onDestroy(); 
    } 

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

     return Service.START_STICKY; 
    } 

    @Override 
    public boolean onUnbind(Intent intent) { 
     return super.onUnbind(intent); 
    } 
+2

La gente ya ha comentado que no se puede mantener un servicio en ejecución pero, dado que parece que el servicio solo registra ContentObservers, parece que la verdadera pregunta es si esos observadores permanecen registrados cuando el servicio muere (creo que do) y cómo evitar volver a registrar nuevas instancias de observador si el servicio se reinicia. – spaaarky21

Respuesta

3

No se puede garantizar que su servicio se ejecute continuamente en Android.

Para el caso de uso que mencione, es mejor confiar en el receptor de difusión como ACTION_NEW_OUTGOING_CALL & SMS_RECEIVED.

Si cree que los receptores Broadcast soportados no cubren todos sus casos de uso. Utilice AlaramManager para iniciar periódicamente su SERVICIO y busque en CALL_LOGS y en la tabla SMS cualquier cambio en los datos y tome las medidas adecuadas (esto puede implicar marcar marcando la última información visitada en CALL_LOGS y la tabla SMS).

+0

Gracias Sukumar. dado que Android no permite que los servicios se ejecuten sin interrupción, tendrá que rediseñar la aplicación en función de los receptores de difusión. – Srao

-1

No puede garantizar que se ejecutará continuamente, pero puede devolver START_STICKY desde onStartCommand, lo que garantiza que Android reiniciará su servicio si se cancela por algún motivo.

2

puede configurar el servicio para que se ejecute en primer plano. esto le dará a su servicio una menor probabilidad de ser asesinado por el sistema operativo.

lea here para obtener más información.

0

El observador de contenido no se registrará tan pronto como se mate su servicio. Entonces registrarse una vez no es una opción y su servicio debe estar ejecutándose todo el tiempo. para garantizar esto, debe devolver START_STICKY desde onStartCommand. También puede iniciar el servicio en primer plano.

Pero, ¿qué sucede si llega una nueva llamada cuando se cancela el servicio? Para manejar esto, puede almacenar el último _id procesado en las preferencias de su aplicación. y cada vez obtenga todos los registros de llamadas nuevos con una identificación mayor que la ID guardada. Debe procesar los registros en el servicio onCreate así como en el observador onChange.

Cuestiones relacionadas