onActivityResult no se llama en Fragmento

La actividad de alojamiento anula onActivityResult(), pero no hizo una llamada a super.onActivityResult() para códigos de resultado no manejados. Aparentemente, aunque el fragmento es el que hace el startActivityForResult() llamada, la actividad tiene la primera oportunidad de manejar el resultado. Esto tiene sentido cuando se considera la modularidad de los fragmentos. Una vez que implementé super.onActivityResult() para todos los resultados no manejados, el fragmento tuvo la oportunidad de manejar el resultado.

Y también de la respuesta de @siqing:

Para obtener el resultado en su fragmento, asegúrese de llamar startActivityForResult(intent,111); en lugar de getActivity().startActivityForResult(intent,111); dentro de tu fragmento.

Creo que llamaste getActivity().startActivityForResult(intent,111);. Deberías llamar startActivityForResult(intent,111);.

Opción 1

Si estas llamando startActivityForResult() del fragmento, entonces deberías llamar startActivityForResult()no, getActivity().startActivityForResult(), ya que dará como resultado el fragmento onActivityResult ().

Si no está seguro de dónde está llamando startActivityForResult() y cómo llamarás a los métodos.

Opción 2

Dado que Activity obtiene el resultado de onActivityResult(), tendrá que anular la actividad onActivityResult() y llama super.onActivityResult() para propagar al fragmento respectivo para códigos de resultados no manejados o para todos.

Si las dos opciones anteriores no funcionan, consulte la opción 3, ya que definitivamente funcionará.

Opción 3

Una llamada explícita desde un fragmento a la función onActivityResult es la siguiente.

En la clase Activity principal, anule el método onActivityResult () e incluso anule el mismo en la clase Fragment y llame como el siguiente código.

En la clase principal:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.dualPane);
    fragment.onActivityResult(requestCode, resultCode, data);
}

En la clase infantil:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // In fragment class callback
}

En caso de que no conozca los fragmentos de su actividad, simplemente enumere todos y envíe los argumentos del resultado de la actividad:

//Java

// In your activity
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    for (Fragment fragment : getSupportFragmentManager().getFragments()) {
        fragment.onActivityResult(requestCode, resultCode, data);
    }
}

// Kotlin

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        for (fragment in supportFragmentManager.fragments) {
            fragment.onActivityResult(requestCode, resultCode, data)
        }
    }

Tengo el mismo problema con el ChildFragmentManager. El administrador no pasará el resultado al fragmento anidado, debe hacerlo manualmente en su fragmento base.

public void onActivityResult(int requestCode, int resultCode, Intent intent) {
    super.onActivityResult(requestCode, resultCode, intent);
    Fragment fragment = (Fragment) getChildFragmentManager().findFragmentByTag(childTag);
    if (fragment != null) {
        fragment.onActivityResult(requestCode, resultCode, intent);
    }
}

Publicación original.

FragmentActivity reemplaza requestCode por uno modificado. Después de eso, cuando onActivityResult() será invocado, FragmentActivity analiza los 16 bits más altos y restaura el índice del Fragmento original. Mira este esquema:

Si tiene algunos fragmentos en el nivel raíz, no hay problemas. Pero si tienes fragmentos anidados, Por ejemplo Fragment con algunas pestañas adentro ViewPager, Que garantizado se enfrentará a un problema (o ya lo enfrenté).

Gracias solo un índice se almacena en el interior requestCode. Ese es el índice de Fragment dentro de su FragmentManager. Cuando usamos fragmentos anidados, hay niños FragmentManagers, que tienen su propia lista de fragmentos. Entonces, es necesario guardar toda la cadena de índices, comenzando desde la raíz FragmentManager.

¿Cómo resolvemos este problema? Existe una solución alternativa común en este post.

GitHub: https://github.com/shamanland/nested-fragment-issue

Este es uno de los problemas más populares. Podemos encontrar muchos hilos sobre este tema. Pero ninguno de ellos me sirve.

Entonces resolví este problema usando esta solución.

Primero entendamos por qué está sucediendo esto.

Podemos llamar startActivityForResult directamente desde Fragmento, pero en realidad los mecánicos detrás son manejados por Actividad.

Una vez que llamas startActivityForResult a partir de un Fragmento, requestCode se cambiará para adjuntar la identidad del Fragmento al código. Eso permitirá que Activity pueda rastrear quién envía esta solicitud una vez que se recibe el resultado.

Una vez que se navegó de regreso a Activity, el resultado se enviará a Activity's onActivityResult con el requestCode modificado que se decodificará a la identidad de requestCode + Fragment original. Después de eso, Activity enviará el resultado de la actividad a ese fragmento a través de onActivityResult. Y todo esta hecho.

El problema es:

La actividad podría enviar el resultado solo al fragmento que se ha adjuntado directamente a la actividad, pero no al anidado. Esa es la razón por la que onActivityResult del fragmento anidado nunca se llamaría sin importar qué.

Solución:

1) Inicie Intent en su Fragmento con el siguiente código:

       /** Pass your fragment reference **/
       frag.startActivityForResult(intent, REQUEST_CODE); // REQUEST_CODE = 12345

2) Ahora en su anulación de actividad para padres **onActivityResult() : **

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
    }

Tienes que llamar a esto en la actividad de los padres para que funcione.

3) En su llamada de fragmento:

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == Activity.RESULT_OK) {

       }
}

Eso es. Con esta solución, podría aplicarse a cualquier fragmento, ya sea que esté anidado o no. Y sí, ¡también cubre todo el estuche! Además, los códigos también son agradables y limpios.

PARA MUCHOS FRAGMENTOS ANIDADOS (por ejemplo, cuando se usa un ViewPager en un fragmento)

En tu actividad principal:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
}

En tu fragmento:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    for (Fragment fragment : getChildFragmentManager().getFragments()) {
        fragment.onActivityResult(requestCode, resultCode, data);
    }
}

En tu fragmento anidado

Actividad de llamada

getParentFragment().startActivityForResult(intent, uniqueInstanceInt);

únicoInstanciaInt - reemplácelo con un int que sea único entre los fragmentos anidados para evitar que otro fragmento trate la respuesta.

Recibir respuesta

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == uniqueInstanceInt ) {
        // TODO your code
    }
}

Atención

Es necesario utilizar un número entre 0 y 65536 en uniqueInstanceInt para evitar errores "Solo se pueden usar 16 bits inferiores para requestCode".

Para aquellos que usan Componente de navegación de Android debe usar en la actividad onActivityResult(...) primaryNavigationFragment para obtener su referencia de fragmento y llamar al fragmento fragment.onActivityResult(...).

Aquí está la actividad onActivityResult(...)

@Override
public void onActivityResult(int requestCode, int resultCode, Intent imageData)
{
    super.onActivityResult(requestCode, resultCode, imageData);

    for (Fragment fragment : getSupportFragmentManager().getPrimaryNavigationFragment().getChildFragmentManager().getFragments())
    {
            fragment.onActivityResult(requestCode, resultCode, imageData);
    }
}

También estaba enfrentando el mismo problema una vez que cambié este bloque de código fuera de un fragmento a una Clase de utilidad, con las parentActivity pasado como argumento,

Intent intent = new Intent(parentActivity, CameraCaptureActivity.class);
parentActivity.startActivityForResult(intent,requestCode);

Entonces no estaba obteniendo ningún valor en onActivityResult método de eso fragmento, Luego, cambié el argumento a fragmento, por lo que la definición revisada de método parecía,

Intent intent = new Intent(fragment.getContext(), CameraCaptureActivity.class);
fragment.startActivityForResult(intent,requestCode);

Después de eso, pude obtener valor en onActivityResult en fragmento

Puedo agregar dos consejos si alguien aún no puede asistir. En el archivo Manifest.xml, asegúrese de que la actividad de alojamiento no haya finalizado cuando vuelva a llamar y que la actividad que se va a iniciar tenga el modo de inicio de serie. Consulte los detalles a continuación:

Para la actividad de alojamiento, establezca la propiedad sin historial como falsa si tiene

android:noHistory="false"

Para que la Actividad se inicie, configure el modo de inicio como estándar si tiene

android:launchMode="standard"

Versión de Kotlin para aquellos que usan el componente de navegación de Android inspirado en la respuesta de Mohit Mehta

 override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    supportFragmentManager.primaryNavigationFragment?.childFragmentManager?.fragments?.forEach { fragment ->
        fragment.onActivityResult(requestCode, resultCode, data)
    }
}

También encontré este problema en un Fragmento. Y llamé startActivityForResult en un parche de DialogFragment.

Pero ahora este problema se ha resuelto:
FragmentClassname.this.startActivityForResult.

PARA FRAGMENTOS ANIDADOS (por ejemplo, cuando se usa un ViewPager)

En tu actividad principal:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
}

En su fragmento principal de nivel superior (fragmento de ViewPager):

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    YourFragment frag = (YourFragment) getChildFragmentManager().getFragments().get(viewPager.getCurrentItem());
    frag.yourMethod(data);  // Method for callback in YourFragment
    super.onActivityResult(requestCode, resultCode, data);
}

En YourFragment (fragmento anidado):

public void yourMethod(Intent data){
    // Do whatever you want with your data
}

En mi caso fue un error de Android (http://technet.weblineindia.com/mobile/onactivityresult-not-getting-called-in-nested-fragments-android/), si usa soporte FragmentActivity tienes que usar getSupportFragmentManager en lugar de getChildFragmentManager:

List<Fragment> fragments = getSupportFragmentManager().getFragments();
if (fragments != null) {
    for (Fragment fragment : fragments) {
        if(fragment instanceof UserProfileFragment) {
            fragment.onActivityResult(requestCode, resultCode, data);
        }
    }
}

En breve,

En fragmento, declare Fragment fragment = this;

después de ese uso fragment.startActivityForResult.

El resultado se devolverá en activityResult.

Solución 1:

Llame a startActivityForResult(intent, REQUEST_CODE); en lugar de getActivity().startActivityForResult(intent, REQUEST_CODE);.

Solución 2:

Cuándo startActivityForResult(intent, REQUEST_CODE); se llama la actividad onActivityResult(requestCode,resultcode,intent) se invoca, y luego puede llamar fragments onActivityResult() desde aquí, pasando el requestCode, resultCode and intent.

Dentro de tu fragmento, llama

this.startActivityForResult(intent, REQUEST_CODE);

donde this se refiere al fragmento. De lo contrario, haz lo que dijo @Clevester:

Fragment fragment = this;
....
fragment.startActivityForResult(intent, REQUEST_CODE);

Yo tambien tuve que llamar

super.onActivityResult(requestCode, resultCode, data);

en la actividad de los padres onActivityResult para que funcione.

(Adapté esta respuesta de la respuesta de @ Clevester).

¡Con Componente de navegación de Android, este problema, cuando tengas fragmentos anidados, podría parecer un misterio irresoluble.

Basado en el conocimiento y la inspiración de las siguientes respuestas en esta publicación, logré inventar una solución simple que funciona:

• Responde en esta publicación
• Responde en esta publicación

En tu actividad onActivityResult(), puede recorrer la lista de Fragmentos activos que obtiene usando el FragmentManager's getFragments() método.

Por favor note que para que pueda hacer esto, debe utilizar el getSupportFragmentManager() o apuntar a API 26 y superior.

La idea aquí es recorrer la lista verificando el tipo de instancia de cada Fragmento en la lista, usando instanceof.

Mientras recorre esta lista de tipos Fragment es ideal, desafortunadamente, cuando está utilizando el componente de navegación de Android, la lista solo tendrá un elemento, es decir NavHostFragment.

¿Y ahora que? Necesitamos que los Fragmentos sean conocidos por NavHostFragment. NavHostFragment en sí mismo es un Fragmento. Entonces usando getChildFragmentManager().getFragments(), una vez más obtenemos un List<Fragment> de Fragmentos conocidos por nuestro NavHostFragment. Recorrimos esa lista comprobando el instanceof cada Fragmento.

Una vez que encontramos nuestro Fragmento de interés en la lista, lo llamamos onActivityResult(), pasándole todos los parámetros que la Actividad onActivityResult() declara.

//  Your activity's onActivityResult()

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        List<Fragment> lsActiveFragments = getSupportFragmentManager().getFragments();
        for (Fragment fragmentActive : lsActiveFragments) {

            if (fragmentActive instanceof NavHostFragment) {

                List<Fragment> lsActiveSubFragments = fragmentActive.getChildFragmentManager().getFragments();
                for (Fragment fragmentActiveSub : lsActiveSubFragments) {

                    if (fragmentActiveSub instanceof FragWeAreInterestedIn) {
                        fragmentActiveSub.onActivityResult(requestCode, resultCode, data);
                    }

                }

            }

        }

    }

La mayoría de estas respuestas siguen diciendo que tienes que llamar super.onActivityResult(...) en tu anfitrión Activity para su Fragment. Pero eso no pareció funcionar para mí.

Entonces, en tu anfitrión Activity deberías llamar a tu Fragments onActivityResult(...) en lugar de. Aquí hay un ejemplo.

public class HostActivity extends Activity {

    private MyFragment myFragment;

    protected void onActivityResult(...) {
        super.onActivityResult(...);
        this.myFragment.onActivityResult(...);
    }
}

En algún momento de tu HostActivity tendrás que asignar this.myFragment Fragment Tu estas usando. O use el FragmentManager para obtener el Fragment en lugar de mantener una referencia a él en su HostActivity. Además, busque null antes de intentar llamar al this.myFragment.onActivityResult(...);.

public class takeimage extends Fragment {

    private Uri mImageCaptureUri;
    private static final int PICK_FROM_CAMERA = 1;
    private static final int PICK_FROM_FILE = 2;
    private String mPath;
    private ImageView mImageView;
    Bitmap bitmap = null;
    View view;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        view = inflater.inflate(R.layout.activity_send_image, container, false);
        final String[] items = new String[] { "From Camera", "From SD Card" };
        mImageView = (ImageView)view.findViewById(R.id.iv_pic);
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(getActivity(), android.R.layout.select_dialog_item, items);
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setTitle("Select Image");

        builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int item) {
                if (item == 0) {
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    File file = new File(Environment.getExternalStorageDirectory(), "tmp_avatar_"
                        + String.valueOf(System.currentTimeMillis())
                        + ".jpg");
                    mImageCaptureUri = Uri.fromFile(file);

                    try {
                        intent.putExtra(
                            android.provider.MediaStore.EXTRA_OUTPUT,
                            mImageCaptureUri);
                        intent.putExtra("return-data", true);

                        getActivity().startActivityForResult(intent,
                            PICK_FROM_CAMERA);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    dialog.cancel();
                } else {
                    Intent intent = new Intent();

                    intent.setType("image/*");
                    intent.setAction(Intent.ACTION_GET_CONTENT);

                    getActivity().startActivityForResult(
                        Intent.createChooser(intent,
                            "Complete action using"), PICK_FROM_FILE);
                }
            }
        });
        final AlertDialog dialog = builder.create();

        Button show = (Button) view.findViewById(R.id.btn_choose);
        show.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                // Switch the tab content to display the list view.
                dialog.show();
            }
        });

    return view;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {

        if (resultCode != Activity.RESULT_OK)
            return;

        if (requestCode == PICK_FROM_FILE) {
            mImageCaptureUri = data.getData();
            // mPath = getRealPathFromURI(mImageCaptureUri); //from Gallery

            if (mPath == null)
                mPath = mImageCaptureUri.getPath(); // from File Manager

            if (mPath != null)
                bitmap = BitmapFactory.decodeFile(mPath);
        } else {
            mPath = mImageCaptureUri.getPath();
            bitmap = BitmapFactory.decodeFile(mPath);
        }
        mImageView.setImageBitmap(bitmap);  
    }

    public String getRealPathFromURI(Uri contentUri) {
        String [] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = managedQuery(contentUri, proj, null, null,null);

        if (cursor == null) return null;

        int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
    }
} 

1. Simplemente puede anular BaseActivity onActivityResult en fragmento baseActivity.startActivityForResult .

2. En BaseActivity, agregue la interfaz y anule onActivityResult.

   private OnBaseActivityResult baseActivityResult;
   public static final int BASE_RESULT_RCODE = 111;
   public interface OnBaseActivityResult{
       void onBaseActivityResult(int requestCode, int resultCode, Intent data);
      }
   }
   
   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
   super.onActivityResult(requestCode, resultCode, data);
   if(getBaseActivityResult() !=null && requestCode == BASE_RESULT_RCODE){
       getBaseActivityResult().onBaseActivityResult(requestCode, resultCode, data);
       setBaseActivityResult(null);
   }
   

3. En implementos de fragmentos OnBaseActivityResult

   @Override
   public void onBaseActivityResult(int requestCode, int resultCode, Intent data) {
   Log.d("RQ","OnBaseActivityResult");
   if (data != null) {
       Log.d("RQ","OnBaseActivityResult + Data");
       Bundle arguments = data.getExtras();
     }
   }
   

Esta solución alternativa funcionará.

Si se enfrenta el problema anterior en Facebook login entonces puede usar el siguiente código en una actividad principal de su fragmento como:

Fragment fragment = getFragmentManager().findFragmentById(android.R.id.tabcontent);
fragment.onActivityResult(requestCode, resultCode, data);

o:

Fragment fragment = getFragmentManager().findFragmentById("fragment id here");
fragment.onActivityResult(requestCode, resultCode, data);

Y agregue la siguiente llamada en su fragmento ...

callbackManager.onActivityResult(requestCode, resultCode, data);

Otro caso de uso que aún no se describe en otras respuestas:

onActivityResult() declarado en el fragmento no se invoca cuando se usa exception.startResolutionForResult():

if (exception is ResolvableApiException) {
    exception.startResolutionForResult(activity!!, MY_REQUEST_CODE)
}

En este caso reemplace exception.startResolutionForResult() con fragmentos startIntentSenderForResult():

if (exception is ResolvableApiException) {
    startIntentSenderForResult(exception.resolution.intentSender, MY_REQUEST_CODE, null, 0, 0, 0, null)
}

Versión de Kotlin (en su actividad onActivityResult ())

 override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    //add following lines in your activity
    if(supportFragmentManager?.fragments!=null && supportFragmentManager?.fragments!!.size>0)
     for (i in 0..supportFragmentManager?.fragments!!.size-1) {
         val fragment= supportFragmentManager?.fragments!!.get(i)
         fragment.onActivityResult(requestCode, resultCode, data)
    }
 }

Agrega esto

public void onClick(View v) {   
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT,MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        startActivityForResult(intent, 1);
}

cuando reemplace su código con este código anterior, automáticamente su este

public void onActivityResult(int requestCode, int resultCode,
@Nullable Intent data){}

El método comenzará a funcionar

//No Need to write this code in onclick method
    Intent intent=new Intent();
    intent.setType("image/*");
    intent.setAction(Intent.ACTION_GET_CONTENT)
    startActivityForResult(intent,1);
    Toast.makeText(getContext(), "image"+intent, Toast.LENGTH_SHORT).show();

Como mencionó Ollie C, hay un error activo para la biblioteca de soporte que usa valores devueltos a onActivityResult cuando está usando fragmentos anidados. Solo lo presioné :-(.

Ver Fragment.onActivityResult no se llama cuando requestCode! = 0.

Tengo la fuerte sospecha de que todas las respuestas aquí no son más que trucos. Los he probado todos y muchos otros, pero sin ninguna conclusión fiable ya que siempre hay algún tipo de problema estúpido. Por mi parte, no puedo confiar en resultados inconsistentes. Si observa la documentación oficial de la API de Android para Fragments, verá que Google establece claramente lo siguiente:

Llame a startActivityForResult (Intent, int) desde la actividad que contiene el fragmento.

Ver: API de fragmentos de Android

Entonces, parecería que el enfoque más correcto y confiable sería llamar realmente startActivityForResult () de la actividad de alojamiento y también manejar el resultado onActivityResult () desde allí.

Tu código tiene un fragmento anidado. Llamar a super.onActivityForResult no funciona

No desea modificar todas las actividades desde las que se puede llamar a su fragmento o hacer una solución alternativa para llamar a cada fragmento en la cadena de fragmentos.

Esta es una de las muchas soluciones que funcionan. cree un fragmento sobre la marcha y conéctelo directamente a la actividad con el administrador de fragmentos de soporte. Luego llame a startActivityForResult desde el fragmento recién creado.

private void get_UserEmail() {

    if (view == null) {
        return;
    }
    ((TextView) view.findViewById(R.id.tvApplicationUserName))
            .setText("Searching device for user accounts...");

    final FragmentManager fragManager = getActivity().getSupportFragmentManager();

    Fragment f = new Fragment() {
        @Override
        public void onAttach(Activity activity) {
            super.onAttach(activity);
            startActivityForResult(AccountPicker.newChooseAccountIntent(null, null,
                    new String[]{"com.google"}, false, null, null, null, null), REQUEST_CODE_PICK_ACCOUNT);
        }

        @Override
        public void onActivityResult(int requestCode, int resultCode,
                                     Intent data) {
            if (requestCode == REQUEST_CODE_PICK_ACCOUNT) {
                String mEmail = "";
                if (resultCode == Activity.RESULT_OK) {
                    if (data.hasExtra(AccountManager.KEY_ACCOUNT_NAME)) {
                        mEmail = data
                                .getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
                    }
                }
                if (mActivity != null) {
                    GoPreferences.putString(mActivity, SettingApplication.USER_EMAIL, mEmail);
                }
                doUser();
            }
            super.onActivityResult(requestCode, resultCode, data);
            fragManager.beginTransaction().remove(this).commit();
        }
    };
    FragmentTransaction fragmentTransaction = fragManager
            .beginTransaction();
    fragmentTransaction.add(f, "xx" + REQUEST_CODE_PICK_ACCOUNT);
    fragmentTransaction.commit();
}

Mi problema fue con la actividad del host. Lo encontré con un conjunto. android:launchMode="standard" ¡Lo eliminé temporalmente y funciona!