Comunicación entre BroadcastReceiver y Activity-Android

android-activity methods

Question

Tengo un receptor de difusión en mi aplicación que se activa cada vez que el usuario recibe una llamada entrante. Ahora, cuando sucede, necesito que el receptor de difusión invoque un método específico en una actividad específica. Ahora, traté de hacer este método estático y por lo tanto disponible, pero algo me dice que es una muy mala idea.

En consecuencia, intenté crear una instancia del receptor de difusión dentro de mi actividad sin declararlo en mi manifiesto, pero el problema es que, cuando la aplicación está desactivada, la actividad no existe y, por lo tanto, no puedo invocar mi método.

Entonces, mi pregunta es: ¿Cómo puedo invocar este método cuando el receptor de difusión se enciende, sin hacerlo "público estático"?

Aquí está mi código de actividad (he eliminado las partes irrelevantes)

package com.silverfix.ringo.activities;
import com.silverfix.ringo.R;
import com.silverfix.ringo.activities.fragments.DataManagerFragment;
import android.app.ActionBar;
import android.app.Activity;
import android.app.FragmentTransaction;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
public class RingtonesActivity extends Activity{
private DataManagerFragment dataManagerFragment;
private IntentFilter filter;
private BroadcastReceiver phoneCall;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ringtones);
ActionBar ab = getActionBar();
ab.setDisplayShowTitleEnabled(false);
ab.setDisplayHomeAsUpEnabled(true);
dataManagerFragment = new DataManagerFragment();
FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.add(dataManagerFragment, "DataManagerFragment");
ft.commit();
filter = new IntentFilter();
filter.addAction("android.intent.action.PHONE_STATE");
phoneCall = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
dataManagerFragment.act();
}
};
registerReceiver(phoneCall, filter);
}
}

Answer 1

Esto podría ayudar: ¿cómo puedo notificar una actividad en ejecución desde un receptor de difusión?

Además, puedes intentar usar Observers

Algo como:

public class BroadcastObserver extends Observable {
private void triggerObservers() {
setChanged();
notifyObservers();
}
public void change() {
triggerObservers();
}
}

En su receptor de difusión:

@Override
public void onReceive(Context context, Intent intent) {
BroadcastObserver bco = new BroadcastObserver();
bco.change();
}

y la Actividad:

public class YourActivity extends Activity implements
Observer {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
BroadcastObserver bco = new BroadcastObserver();
bco.addObserver(this);
}
@Override
public void update() {
//TODO: call your desired function
}
}

Answer 2

Puedes usar observadores, como

public class MyReceiver extends BroadcastReceiver {
public MyReceiver() {
}
@Override
public void onReceive(Context context, Intent intent) {
ObservableObject.getInstance().updateValue(intent);
}
}

public class MainActivity extends Activity implements Observer {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ObservableObject.getInstance().addObserver(this);
}
@Override
public void update(Observable observable, Object data) {
Toast.makeText(this, String.valueOf("activity observer " + data), Toast.LENGTH_SHORT).show();
}
}

public class ObservableObject extends Observable {
private static ObservableObject instance = new ObservableObject();
public static ObservableObject getInstance() {
return instance;
}
private ObservableObject() {
}
public void updateValue(Object data) {
synchronized (this) {
setChanged();
notifyObservers(data);
}
}
}

El receptor se puede utilizar a través de manifiesto. ObservableObject - debe ser singleton.

Answer 3

Si alguien necesita una comunicación bidireccional entre un BroadcastReceiver y una Activity, escribí esta clase de utilidad que simplifica la invocación de Métodos entre sí y aún así es segura para la memoria.

https://gist.github.com/Jenjen1324/4a0c03beff827082cb641fc8fe2c4e71