¿Cómo forzar a Acivity principal a esperar a la subactividad en Android?

Estoy de acuerdo con Nikolay esta es definitivamente la forma de Android para hacer esto.

Inicie la subactividad con startActivityForResult en la subactividad use setResult para agregar un código de resultado y una intención con todos los números que necesita en el paquete de datos.

En su primera actividad sobrescribir OnActivityResult y recuperar los números de la intención.

Si utiliza la variable estática esto parece más fácil en el primer momento, pero es muy inseguro y hay algunos casos que esto puede no funcionar. Si su programa se envía al fondo, sus actividades se guardarán, pero si el teléfono se agota en la memoria, el sistema cerrará su programa y después de que el usuario lo vuelva a iniciar, todo parecerá como el momento en que el usuario lo dejó, pero las variables estáticas se recrearán para Su valor de inicialización.

Trate de acostumbrarse a la forma en que funciona el ciclo de vida de la actividad de Android. El uso de este enfoque resultará en menos memoria usada y una experiencia de usuario mucho mejor.

Puede ser que estoy perdiendo algo, pero ¿por qué no sólo utilizan startActivityForResult y onActivityResult mecanismo? Usted podría obtener el resultado de su subactividad de la intención que resultó con.
Editar: BTW en la medida de lo que entiendo, si se ejecuta Object.wait() del código de Activity si se celebrará UI tread whitch puede dar lugar a la Application not responding error.

Echa un vistazo al ejemplo del Bloc de notas , que cubre exactamente esta situación. Y como otros han dicho, la forma de Android es que tu primera actividad inicie tu segunda actividad (no sub-actividad!) Y escucha de forma asíncrona una respuesta (no pausa ni espera, sin necesidad de unirse, etc.).

Bueno … puedes hacerlo de esta manera (por cierto, no hay manera directa):

Tener una clase singleton, llamémosla Monitor:

 public class Singleton { private Singleton() { } private static Singleton instance = new Singleton(); public static Singleton getInstance() { return instance; } } public class ParentActivity extends Activity { private void startAndWait() { Intent i = new Intent(); // initialize i startActivityForResult(i); Singleton si = Singleton.getInstance(); synchronized(si) { si.wait(); } //do remaining work } } public class ChildActivity extends Activity { protected void onCreate(Bundle savedInstance) { //do all the work Singleton si = Singleton.getInstance(); synchronized(si) { si.notify(); } } } 

No estoy aquí para juzgar si es un buen patrón o no, pero si realmente necesita una actividad para esperar una subactividad, puede probar este enfoque:

• Definir un objeto (bloqueo) sobre el cual se sincronizan las dos actividades; Esto puede (debe) funcionar también como el objeto para intercambiar datos entre esas dos actividades y por lo tanto debe ser definido como estático
• En la actividad de los padres, inicie una tarea asíncrona (ya que el subproceso principal de la interfaz de usuario no puede estar en estado de espera)
• En la tarea asíncrona, inicie su subactividad
• La tarea asíncrca espera en la cerradura hasta que se notifique
• La subactividad hace lo que necesita y notifica el hilo de espera cuando termina

Hice una cosa similar en mi aplicación y la IMHO tenía una buena razón para esto (no molestar a un usuario con pantalla de inicio de sesión al iniciar o reanudar la aplicación, la aplicación intenta reutilizar las credenciales almacenadas en un lugar seguro y sólo en caso de que falla , Así que sí, básicamente cualquier actividad en mi aplicación puede "pausar" y esperar hasta que el usuario proporcione credenciales correctas en la actividad de inicio de sesión en la que termina la pantalla de inicio de sesión y la aplicación continúa exactamente donde se detuvo (en La actividad de los padres).

En el código sería algo como esto:

ParentActivity:

  public class ParentActivity extends Activity { private static final String TAG = ParentActivity.class.getSimpleName(); public static class Lock { private boolean condition; public boolean conditionMet() { return condition; } public void setCondition(boolean condition) { this.condition = condition; } } public static final Lock LOCK = new Lock(); @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.parent_layout); // do whatever logic you need and anytime you need to stat sub-activity new ParentAsyncTask().execute(false); } private class ParentAsyncTask extends AsyncTask<Boolean, Void, Boolean> { @Override protected Boolean doInBackground(Boolean... params) { // do what you need and if you decide to stop this activity and wait for the sub-activity, do this Intent i = new Intent(ParentActivity.this, ChildActivity.class); startActivity(i); synchronized (LOCK) { while (!LOCK.conditionMet()) { try { LOCK.wait(); } catch (InterruptedException e) { Log.e(TAG, "Exception when waiting for condition", e); return false; } } } return true; } } } 

ChildActivity:

 public class ChildActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.child_layout); // do whatever you need in child activity, but once you want to finish, do this and continue in parent activity synchronized (ParentActivity.LOCK) { ParentActivity.LOCK.setCondition(true); ParentActivity.LOCK.notifyAll(); } finish(); // if you need the stuff to run in background, use AsyncTask again, just please note that you need to // start the async task using executeOnExecutor method as you need more executors (one is already occupied), like this: // new ChildAsyncTask().executeOnExecutor(ChildAsyncTask.THREAD_POOL_EXECUTOR, false); } }