Rückruf einmal Aktivität in einem anderen Prozess gestartet?

Question

Wenn ich Activity() für eine Aktivität in einem anderen Prozess starte; Gibt es eine gute Möglichkeit, einen Rückruf am Startpunkt (Starten der neuen Aktivität aus einem Hintergrunddienst) zu erhalten, dass die neue Aktivität wirklich begonnen hat? Ich meine, ich kann eine Sendung machen, aber das scheint lahm. Gibt es dafür einen besseren Weg?

Answer 1

Im Grunde, was Sie fragen, ist IPC. Google es für weitere Informationen.

Um dies zu erreichen, müssen Sie eine Serviceklasse erstellen und die beiden Aktivitäten an sie binden.

Eine Beispiel-Service-Klasse würde so aussehen.

public class MyService extends Service{ 
    //create a handler that will be used to handle messages 
    //this is just an example. Use static handlers 
    final Handler handler=new Handler(){ 
     public void handleMessage(Message msg){ 
      //I've just created a static feild.Check below. 
      MyFirstActivity.activity.seconActivityStarted(); 
     } 
    } 

    //create a Messenger object 
    Messenger messenger=new Messenger(handler); 

    @Override 
    public IBinder onBind(Intent intent){ 
     return messenger.getBinder() 
    } 
} 

Jetzt sind die Dinge einfach.

Jetzt müssen Sie die erste Aktivität mit der Dienstleistung binden.

public class MyFirstActivity extends AppCompatActivity{ 
    //for the time being I'll just create a static field that will be used. 
    //you can use an interface 
    static MyFirstActivity activity; 
    //create a ServiceConnection 
    ServiceConnection connection=new ServiceConnection(/*contents of the service connection */); 

    public void onStart(){ 
     super.onStart(); 
     activity=this; 
     bindService(new Intent(this,MyService.class),connection,Context.BIND_AUTO_CREATE)); 
    } 

    //following method will be called by the handler in the service 
    public void secondActivityStarted(){ 
     //some code 
    } 

    //you have to handle the activity lifecycle with the bound service. 
    //right now its described here 

} 

Nun ist die zweite Aktivität

public class SecondActivity extends AppCompatActivity{ 
    //create a ServiceConnection 
    ServiceCOnnection serviceConnection=new ServiceConnection(){ 
     //call the handler at onServiceConnected 
     public void onServiceCOnnected(ComponentName name, IBinder service){ 
       Messenger messenger=new Messenger(service); 
       //compose a Message object as you like 
       messenger.send(new Message()); 
     } 
    }; 

    //bind this activity to the same service 
    public void onStart(){ 
     super.onStart(); 
     bindService(new Intent(this,com.package.name.MySerice.class),serviceConnection,Context.BIND_AUTO_CREATE); 
    } 
} 

Das ist es. Ändern Sie dies entsprechend den Anforderungen.

P.S.Above genannten Code ist nur Arbeitsstruktur.

Answer 2

Wenn Sie startActivity() für eine Aktivität in demselben oder einem anderen Prozess ausführen (und davon ausgehen, dass die zweite Aktivität gestartet wird), wird die aufrufende Aktivität in den ersten Status PAUSED und anschließend in den Status STOPPED versetzt. Das bedeutet, dass kein Rückruf durchgeführt werden würde. Sie können jedoch startActivityForResult() anstelle von startActivity() aufrufen und onActivityResult() -Aufruf empfangen.

Answer 3

Fügen Sie eine Klasse MyApplication hinzu, die Anwendung und Erwähnung auch in Ihrem Manifest erweitert und zwei boolesche Variablen darin einfügt.

 private static boolean activityVisible; 

    public static void activityResumed() { 
    activityVisible = true; 
} 

public static void activityPaused() { 
    activityVisible = false; 
} 
public static boolean isActivityVisible() { 
    return activityVisible; 
} 

und so können Sie jetzt anrufen verwenden activityPaused(), wenn Sie das tun startActivity() auf onPause() und OnStop() die aktuellen Aktivität, und wenn Sie zurück zu gleicher Aktivität zurückkehren nennen activityResumed() in überschriebenen onResume() -Methode.

Jetzt können Sie mit MyApplication.isActivityVisible() erfahren, ob Ihre Aktivität ausgeführt wird oder pausiert.