Referenzieren der aktuellen oder Hauptaktivität aus einer anderen Klasse

Wenn Sie bereits über einen gültigen Kontext verfügen, verwenden Sie einfach diesen Befehl: Activity activity = (Activity) context;

Das Passieren von Kontext ist der bessere Weg für die Wiederholungstätigkeit.

Sie können den Kontext an eine andere Klasse übergeben.

IN Aktivität ::

AnotherClass Obj  = new AnotherClass(this);

IN einer anderen Klasse

class AnotherClass{

public AnotherClass(Context Context){

    }

}

Sie können die erforderlichen Methoden in Ihrer Aktivität implementieren und einen Handler implementieren. Übergeben Sie dann einfach eine Handler-Instanz an Ihre Klassen, wo Sie eine Nachricht für den Handler erhalten und an das Ziel senden können.

Ich habe einen Weg gefunden, die Aktivität zu einer Nichtaktivitätsklasse zu bringen, die ich in Foren nicht gesehen habe. Dies geschah nach zahlreichen fehlgeschlagenen Versuchen, getApplicationContext () zu verwenden und den Kontext als Parameter an Konstruktoren zu übergeben, von denen keiner zu Activity führte. Ich habe gesehen, dass meine Adapter den eingehenden Kontext in Activity umwandeln, und ich habe die gleiche Besetzung für meine Nicht-Aktivitäts-Klassenkonstrukteure gemacht:

public class HandleDropdown extends Application{
...
    public Activity activity;
...
public HandleDropdown() {
    super();
}
public HandleDropdown(Activity context) {
    this.activity = context;
    this.context = context;
}
public void DropList(View v,Activity context) {
    this.activity = context;
    this.context = context; 
...
}

Nach dieser Umwandlung von Kontext in Aktivität konnte ich diese Aktivität überall dort einsetzen, wo ich einen Aktivitätskontext benötigte.

Sie können Ihre Anwendungsinstanz zu einem Singleton machen und ihn verwenden, wenn Sie einen Kontext benötigen

Ein Beispiel ist in dieser Frage:
Android-Anwendung als Singleton

Auf diese Weise können Sie einen Kontext erhalten, wenn Sie ihn benötigen
Context context = MyApplication.getInstance()

Dies ist möglicherweise nicht die sauberste Lösung, hat aber bisher bei mir gut funktioniert

Es gibt viele Möglichkeiten zur Kommunikation von Aktivitäten.

sie können verwenden:

• die startActivityForResult-Methode

• ein System aus Broadcast-Nachricht und Empfänger (Sie können ein Ereignis aus der tatsächlichen Aktivität senden und einen Empfänger in der Zielaktivität registrieren. Denken Sie daran, dass die Zielaktivität zuvor initialisiert und nicht abgeschlossen sein muss)

• speichern Sie, wie Sie sagen, eine Referenz der Zielaktivität, wo immer Sie möchten.

Wir haben dafür einen Rahmen geschaffen. Wir haben eine BaseActivity-Klasse, die von Activity erbt. Sie überschreibt alle Lebenszyklusmethoden und verfügt über einige statische (Klassen-) Variablen, die den Aktivitätsstack nachverfolgen. Wenn etwas wissen soll, was die aktuelle Aktivität ist, ruft es einfach eine statische Methode in BaseActivity auf, die die Aktivität auf unseren privat verwalteten Stack zurückgibt.

Es ist irgendwie hackig, aber es funktioniert. Ich bin mir nicht sicher, ob ich es empfehlen würde.

Ich bin neu bei Android, daher kann mein Vorschlag unanständig aussehen, aber was ist, wenn Sie lediglich einen Verweis auf Ihre Aktivität als Privateigentum erstellen und diesen in der OnCreate-Methode zuweisen? Sie können sogar Ihre CustomActivity mit OnCreate erstellen und alle Ihre Aktivitäten von Ihrer CustomActivity ableiten, nicht von der von adnroid bereitgestellten generischen Aktivität.

class blah extends Activity{
  private Activity activityReference;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        activityReference = this;
    }

}

Intent i = new Intent(activityReference, SomeOtherActivity.class)

usw

Behandeln Sie die Absicht in der Klasse, in der Sie diese Methoden ausführen möchten, und senden Sie Ihre Informationen in einem Bündel wie folgt:

    Intent i = new Intent("Android.intent.action.MAIN");
    i.setComponent(new ComponentName("com.my.pkg","com.my.pkg.myActivity"));
    Bundle data = new Bundle();

    i.putExtras(data);

    startActivityForResult(i);

Verwenden Sie dann einen OnActivityResultListener, um die neuen Daten zu übernehmen.

public static Activity getLaunchActivity()
{
    final Class<?> activityThreadClass = Class.forName("Android.app.ActivityThread");

    final Method methodApp = activityThreadClass.getMethod("currentApplication");
    App = (Application) methodApp.invoke(null, (Object[]) null);
    Intent launcherIntent = App.getPackageManager().getLaunchIntentForPackage(App.getPackageName());
    launchActivityInfo = launcherIntent.resolveActivityInfo(App.getPackageManager(), 0);
    Class<?> clazz;
    try
    {
        clazz = Class.forName(launchActivityInfo.name);
        if(clazz != null)
            return Activity.class.cast(clazz.newInstance());
    }
    catch (Exception e)
    {}

    return null;
}

Ich habe dieses Problem gelöst, indem eine Einzelklasse eine Instanz der Klasse als Mitglied hat.

public class InterActivityReferrer <T> {
    HashMap<Integer, T> map;
    ArrayList<Integer> reserve;

    public InterActivityReferrer() {
        map = new HashMap<>();
        reserve = new ArrayList<>();
    }

    public synchronized int attach(T obj) {
        int id;
        if (reserve.isEmpty()) {
            id = reserve.size();
        }
        else {
            id = reserve.remove(reserve.size() - 1);
        }

        map.put(id, obj);
        return id;
    }

    public synchronized T get(int id) {
        return map.get(id);
    }

    public synchronized T detach(int id) {
        T obj = map.remove(id);
        if (obj != null) reserve.add(id);
        return obj;
    }
}

Diese Klasse kann ein T-Objekt abrufen und eine eindeutige Ganzzahl zurückgeben, die dem Objekt durch attach () zugewiesen wurde. Zugewiesene Ganzzahlen kollidieren nicht miteinander, es sei denn, HashMap schlägt fehl. Jede zugewiesene Ganzzahl wird freigegeben, wenn ihr entsprechendes Objekt von detach () getrennt wird. Freigegebene Ganzzahlen werden wiederverwendet, wenn ein neues Objekt angehängt wird.

Und aus einer Einzelklasse:

public class SomeSingleton {
    ...
    private InterActivityReferrer<Activity> referrer = new InterActivityReferrer<>();
    ...
    public InterActivityReferrer<Activity> getReferrer() {return referrer;}
}

Und von einer Aktivität, die referenziert werden muss:

    ...
    int activityID = SomeSingleton.getInstance().getReferrer().attach(this);
    ...

Damit wird nun eine eindeutige Ganzzahl zurückgegeben, die dieser Aktivitätsinstanz entspricht. Eine Integer-Zahl kann mit Intent und putExtra () an eine andere Startaktivität übergeben werden.

    ...
    Intent i = new Intent(this, AnotherActivity.class);
    i.putExtra("thisActivityID", activityID);
    startActivityForResult(i, SOME_INTEGER);
    ...

Und von der anderen Tätigkeit:

    ...
    id refereeID = getIntent().getIntExtra("thisActivityID", -1);
    Activity referredActivity = SomeSingleton.getInstance().getReferrer().get(refereeID);
    ...

Und zum Schluss kann auf die Aktivität verwiesen werden. InterActivityReferrer kann für jede andere Klasse verwendet werden.

Ich hoffe das hilft.