it-swarm.com.de

onActivityResult wird in Fragment nicht aufgerufen

Die Aktivität, die dieses Fragment hostet, wird mit onActivityResult aufgerufen, wenn die Kameraaktivität zurückkehrt.

Mein Fragment startet eine Aktivität für ein Ergebnis mit der Absicht, dass die Kamera ein Bild aufnimmt. Die Bildanwendung wird gut geladen, nimmt ein Bild auf und kehrt zurück. Das onActivityResult wird jedoch niemals getroffen. Ich habe Haltepunkte gesetzt, aber es wird nichts ausgelöst. Kann ein Fragment onActivityResult haben? Ich denke schon, da es eine vorgesehene Funktion ist. Warum wird das nicht ausgelöst?

ImageView myImage = (ImageView)inflatedView.findViewById(R.id.image);
myImage.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent cameraIntent = new Intent(Android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
        startActivityForResult(cameraIntent, 1888);
    }
});

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if( requestCode == 1888 ) {
        Bitmap photo = (Bitmap) data.getExtras().get("data");
        ((ImageView)inflatedView.findViewById(R.id.image)).setImageBitmap(photo);
    }
}
811
Spidy

Die Hosting-Aktivität überschreibt onActivityResult(), ruft jedoch nicht super.onActivityResult() für nicht behandelte Ergebniscodes auf. Obwohl das Fragment den Aufruf von startActivityForResult() ausführt, erhält die Aktivität anscheinend den ersten Versuch, mit dem Ergebnis umzugehen. Dies ist sinnvoll, wenn Sie die Modularität von Fragmenten berücksichtigen. Nachdem ich super.onActivityResult() für alle nicht verarbeiteten Ergebnisse implementiert hatte, bekam das Fragment einen Versuch, das Ergebnis zu verarbeiten.

Und auch von @siqing Antwort:

Um das Ergebnis in Ihrem Fragment zu erhalten, stellen Sie sicher, dass Sie startActivityForResult(intent,111); anstelle von getActivity().startActivityForResult(intent,111); in Ihrem Fragment aufrufen.

1172
Spidy

Ich denke, Sie haben getActivity().startActivityForResult(intent,111); angerufen. Sie sollten startActivityForResult(intent,111); aufrufen.

315
siqing

Option 1:

Wenn Sie startActivityForResult() vom Fragment aus aufrufen, sollten Sie startActivityForResult() aufrufen, nicht getActivity().startActivityForResult(), da dies zu einem Fragment onActivityResult () führt.

Wenn Sie nicht sicher sind, wo Sie startActivityForResult() aufrufen und wie Sie Methoden aufrufen.

Option 2:

Da Activity das Ergebnis von onActivityResult() erhält, müssen Sie die onActivityResult() der Activity überschreiben und super.onActivityResult() aufrufen, um unbehandelte Ergebniscodes oder alle auf das jeweilige Fragment zu übertragen.

Wenn die beiden oben genannten Optionen nicht funktionieren, beziehen Sie sich auf Option 3, da dies definitiv funktionieren wird.

Option 3:

Ein expliziter Aufruf des Fragments an die Funktion onActivityResult lautet wie folgt.

Überschreiben Sie in der übergeordneten Activity-Klasse die onActivityResult () -Methode und überschreiben Sie diese sogar in der Fragment-Klasse und rufen Sie den folgenden Code auf.

In der Elternklasse:

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

In der Kinderklasse:

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

Ich habe das gleiche Problem mit dem ChildFragmentManager. Der Manager übergibt das Ergebnis nicht an das verschachtelte Fragment. Sie müssen dies manuell in Ihrem Basisfragment tun.

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);
    }
}
79
MinceMan

Falls Sie keine Fragmente in Ihrer Aktivität kennen, listen Sie sie einfach alle auf und senden Sie die Argumente für die Aktivitätsergebnisse:

// 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);
    }
}
79
ruX

Originalbeitrag.

FragmentActivity ersetzt requestCode durch ein modifiziertes. Wenn danach onActivityResult() aufgerufen wird, analysiert FragmentActivity die höheren 16 Bits und stellt den Index des ursprünglichen Fragments wieder her. Schauen Sie sich dieses Schema an:

Enter image description here

Wenn Sie ein paar Fragmente auf der Root-Ebene haben, gibt es keine Probleme. Aber wenn Sie verschachtelte Fragmente haben, zum Beispiel Fragment mit ein paar Tabulatoren innerhalb ViewPager, werden Sie garantiert mit einem Problem konfrontiert ​​(oder schon konfrontiert).

Weil nur ein Index in requestCode gespeichert ist. Das ist der Index von Fragment innerhalb seines FragmentManager. Wenn wir verschachtelte Fragmente verwenden, gibt es untergeordnete FragmentManagers mit einer eigenen Liste von Fragmenten. Daher muss die gesamte Indexkette gespeichert werden, beginnend mit root FragmentManager.

Enter image description here

Wie lösen wir dieses Problem? Es gibt eine allgemeine Problemumgehungslösung in diesem Beitrag .

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

57
Oleksii K.

Dies ist eines der beliebtesten Themen. Wir können viele Themen zu diesem Thema finden. Aber keiner von ihnen ist nützlich für MICH.

Also habe ich dieses Problem mit dieser Lösung gelöst.

Lassen Sie uns zuerst verstehen, warum dies geschieht.

Wir können startActivityForResult direkt von Fragment aufrufen, aber tatsächlich werden alle dahinter liegenden Mechaniker von Activity behandelt.

Wenn Sie startActivityForResult von einem Fragment aufrufen, wird requestCode geändert, um die Identität des Fragments an den Code anzuhängen. Dadurch kann Activity nachverfolgen, wer diese Anfrage gesendet hat, sobald das Ergebnis eingegangen ist.

Sobald Activity zurück navigiert wurde, wird das Ergebnis mit dem geänderten requestCode an Activitys onActivityResult gesendet, der in die ursprüngliche requestCode + Fragment-Identität decodiert wird. Danach sendet Activity das Aktivitätsergebnis über onActivityResult an dieses Fragment. Und es ist alles erledigt.

Das Problem ist:

Activity kann das Ergebnis nur an das Fragment senden, das direkt an Activity angehängt wurde, jedoch nicht an das verschachtelte Fragment. Das ist der Grund, warum onActivityResult von verschachtelten Fragmenten nie aufgerufen wurde, egal wie.

Lösung:

1) Starten Sie Intent in Ihrem Fragment mit folgendem Code:

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

2) Überschreiben Sie jetzt in Ihrer übergeordneten Aktivität ** onActivityResult(): **

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

Sie müssen dies in der übergeordneten Aktivität aufrufen, damit es funktioniert.

) In Ihrem Fragmentaufruf:

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

       }
}

Das ist es. Mit dieser Lösung kann es für jedes einzelne Fragment angewendet werden, unabhängig davon, ob es verschachtelt ist oder nicht. Und ja, es deckt auch den ganzen Fall ab! Darüber hinaus sind die Codes auch schön und sauber.

42
KishuDroid

FÜR VIELE VERSCHACHTETE FRAGMENTE (z. B. bei Verwendung eines ViewPagers in einem Fragment)

In Ihrer Haupttätigkeit:

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

In deinem Fragment:

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

In Ihrem verschachtelten Fragment

Aktivität anrufen

getParentFragment().startActivityForResult(intent, uniqueInstanceInt);

uniqueInstanceInt - Ersetzen Sie es durch ein int, das unter den verschachtelten Fragmenten eindeutig ist, um zu verhindern, dass ein anderes Fragment die Antwort behandelt.

Antwort erhalten

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

Achtung

Eine Zahl zwischen 0 und 65536 muss in uniqueInstanceInt verwendet werden, um Fehler zu vermeiden "Kann nur niedrigere 16 Bits für requestCode verwenden".

18

Ich kann zwei Ratschläge hinzufügen, wenn jemand es immer noch nicht schafft. Stellen Sie in der Datei "Manifest.xml" sicher, dass die Hosting-Aktivität beim Rückruf nicht beendet wurde und die zu startende Aktivität standardmäßig den Startmodus aufweist. Siehe details wie folgt:

Setzen Sie für die Hosting-Aktivität die Eigenschaft no history auf false, wenn Sie haben

Android:noHistory="false"

Stellen Sie den Startmodus als Standard ein, wenn Activity gestartet werden soll

Android:launchMode="standard"
14
jowett

Ich hatte auch das gleiche Problem, als ich diesen Codeblock außerhalb einer Fragment in eine Utility-Klasse mit parentActivity verschoben habe. übergeben als Argument ,

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

Dann habe ich in der Methode onActivityResult von Fragment keinen Wert erhalten. Danach habe ich das Argument in geändert. Fragment, so sah die überarbeitete Definition der Methode aus,

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

Danach konnte ich Wert in onActivityResult auf dem Fragment erhalten

11

Ich bin diesem Problem auch in einem Fragment begegnet. Und ich habe startActivityForResult in einem DialogFragment angerufen.

Nun ist dieses Problem behoben:
FragmentClassname.this.startActivityForResult.

10
Courysky

Lösung 1:

Rufen Sie startActivityForResult(intent, REQUEST_CODE); anstelle von getActivity().startActivityForResult(intent, REQUEST_CODE); auf.

Lösung 2:

Wenn startActivityForResult(intent, REQUEST_CODE); aufgerufen wird, wird die onActivityResult(requestCode,resultcode,intent) der Aktivität aufgerufen, und Sie können von hier aus fragments onActivityResult() aufrufen und dabei requestCode, resultCode and intent übergeben.

6
Amey Haldankar

In meinem Fall war es ein Android Bug ( http://technet.weblineindia.com/mobile/onactivityresult-not-getting-called-in-nested-fragments-Android/ ), wenn Sie unterstütztes FragmentActivity verwenden, müssen Sie getSupportFragmentManager anstelle von getChildFragmentManager verwenden:

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

FÜR NESTED FRAGMENTS (zum Beispiel bei Verwendung eines ViewPagers)

In Ihrer Haupttätigkeit:

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

In Ihrem Hauptfragment der obersten Ebene (ViewPager-Fragment):

@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);
}

In YourFragment (verschachteltes Fragment):

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

Ruf in deinem Fragment an

this.startActivityForResult(intent, REQUEST_CODE);

dabei bezieht sich this auf das Fragment. Ansonsten mache wie @Clevester sagte:

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

Ich musste auch anrufen

super.onActivityResult(requestCode, resultCode, data);

in der übergeordneten Aktivität onActivityResult, damit es funktioniert.

(Ich habe diese Antwort aus der Antwort von @ Clevester angepasst.)

5
Suragch

Zusamenfassend,

Deklarieren Sie in fragment Fragment fragment = this;

danach benutze fragment.startActivityForResult.

Das Ergebnis wird in activityResult zurückgegeben.

5
Clevester

Die meisten dieser Antworten besagen, dass Sie super.onActivityResult(...) in Ihrem Host Activity für Ihr Fragment aufrufen müssen. Aber das schien bei mir nicht zu funktionieren.

In Ihrem Host Activity sollten Sie stattdessen FragmentsonActivityResult(...) aufrufen. Hier ist ein Beispiel.

public class HostActivity extends Activity {

    private MyFragment myFragment;

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

Irgendwann in Ihrem HostActivity müssen Sie this.myFragment das Fragment zuweisen, das Sie verwenden. Oder verwenden Sie FragmentManager, um Fragment abzurufen, anstatt in Ihrem HostActivity einen Verweis darauf zu speichern. Überprüfen Sie auch, ob null vorhanden ist, bevor Sie versuchen, die Funktion this.myFragment.onActivityResult(...); aufzurufen.

4
prolink007
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);
    }
} 
3
  1. Sie können BaseActivity onActivityResult für Fragment baseActivity.startActivityForResult einfach überschreiben.

  2. Fügen Sie in BaseActivity die Schnittstelle hinzu und überschreiben Sie 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. On Fragment implementiert 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();
      }
    }
    

Diese Problemumgehung erledigt den Trick.

3
Khaled Lela

Wenn das obige Problem bei Facebook-Login auftritt, können Sie den folgenden Code in einer übergeordneten Aktivität Ihres Fragments verwenden:

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

Oder:

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

Und fügen Sie den folgenden Aufruf in Ihr Fragment ein ...

callbackManager.onActivityResult(requestCode, resultCode, data);
3
Ketan Patel

Mein Problem war mit der Host-Aktivität. Ich habe es mit einem Set gefunden. Android:launchMode="standard" Ich habe es vorübergehend entfernt und es funktioniert!

1
Chulo

Wenn Sie verschachtelte Fragmente verwenden, funktioniert dies auch:

getParentFragment().startActivityForResult(intent, RequestCode);

Darüber hinaus müssen Sie super.onActivityResult aus der übergeordneten Aktivität aufrufen und die onActivityResult -Methode des Fragments ausfüllen.

1
Oguz Ozcan

Ihr Code hat ein verschachteltes Fragment. Das Aufrufen von super.onActivityForResult funktioniert nicht.

Sie möchten nicht jede Aktivität ändern, von der aus Ihr Fragment aufgerufen werden kann, und Sie möchten nicht jedes Fragment in der Fragmentkette aufrufen.

Hier ist eine von vielen funktionierenden Lösungen. Erstellen Sie ein Fragment im Handumdrehen und verbinden Sie es direkt mit der Aktivität mit dem Support-Fragment-Manager. Rufen Sie dann startActivityForResult aus dem neu erstellten Fragment auf.

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();
}
1
danny117

Ich habe den starken Verdacht, dass alle Antworten hier nichts anderes als Hacks sind. Ich habe sie alle und viele andere ausprobiert, aber ohne verlässliche Schlussfolgerung, da es immer eine Art dummes Problem gibt. Ich kann mich nicht auf widersprüchliche Ergebnisse verlassen. Wenn Sie sich die offizielle Android API-Dokumentation für Fragmente ansehen, werden Sie feststellen, dass Google die folgenden Aussagen klar macht:

Rufen Sie startActivityForResult (Intent, int) aus dem Fragment auf, das Activity enthält.

Siehe: Android Fragment API

Es scheint also, dass der korrekteste und zuverlässigste Ansatz darin besteht, startActivityForResult () aus der Hosting-Aktivität aufzurufen und auch das resultierende onActivityResult ( ) von dort.

1
Chris

Wie Ollie C bereits erwähnte, gibt es einen aktiven Fehler in der Support-Bibliothek, der die an onActivityResult zurückgegebenen Werte verwendet, wenn Sie verschachtelte Fragmente verwenden. Ich habe es gerade geschlagen : .

Siehe --- (Fragment.onActivityResult wird nicht aufgerufen, wenn requestCode! =.

1
chaqke

Ich mache nur eine Umgehungsmethode:

public static Fragment _tempFragment = null;
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if(_tempFragment != null)
        _tempFragment.onActivityResult(requestCode, resultCode, data);
}

Legen Sie in Ihrem Fragment vor startActivityResult fest

MainActivity._tempFragment = this;

Nach onActivityResult <- in Fragment

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

     // Do your job
     {

     }
     MainActivity._tempFragment = null;
}
0
Ah Lam

Ein weiterer Anwendungsfall, der in anderen Antworten noch nicht beschrieben wurde:

onActivityResult(), das in Fragment deklariert ist, wird bei Verwendung von exception.startResolutionForResult() nicht aufgerufen:

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

In diesem Fall ersetzen Sie exception.startResolutionForResult() durch das startIntentSenderForResult() des Fragments:

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

Verwenden Sie einfach den folgenden Code für das Fragment.

@Override
public void onOtherButtonClick(ActionSheet actionSheet, int index) {

    if (index == 1)
    {
        Intent intent = new Intent(Intent.ACTION_PICK,
                                   Android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        intent.setType("image/*");
        startActivityForResult(Intent.createChooser(intent,
                                                    "Select Picture"), 1);
     }
}

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (resultCode == 1) {
        if (requestCode == 1) {
            Uri selectedImageUri = data.getData();
            //selectedImagePath = getPath(selectedImageUri);
        }
    }
}

onActivityResult ruft auf, ohne das übergeordnete Element anzurufen.

0
Kirtikumar A.

Eine der einfachsten Möglichkeiten besteht darin, eine Aktivität von Ihrem Fragment aus zu starten.

startActivity(ActivityName);

Fügen Sie dann hinzu, dass Sie startActivityForResult(intent,"1"); aus Ihrer Aktivität aufrufen und onActivityResult in Ihre Aktivität einfügen

startActivityForResult(intent,"1");

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.dualPane);
    fragment.onActivityResult(requestCode, resultCode, data);
// perform other activity result like fetching from Uris or handling cursors

finish(); // finish the activity will  get to back to your fragment.
}
0
Rohit Goyal

Kotlin-Version (In Ihrer Aktivität aufActivityResult ())

 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)
    }
 }
0
Ranjith Kumar

An einem Punkt hat niemand mention, der sicherstellt, dass Ihre Host-Aktivität Startmodus nicht auf singleInstance oder singleTask eingestellt ist.

onActivityResult funktioniert nicht, wenn der Startmodus auf SingleInstance oder SingleTask eingestellt ist. oder Sie rufen Ihre Aktivität mit diesen IntentFilters auf

Der Startmodus standard oder singleTop funktioniert einwandfrei.

0
Xar E Ahmer

Wenn es Probleme mit der Methode onActivityResult gibt, die sich in der Fragmentklasse befindet, und Sie etwas aktualisieren möchten, das sich auch in der Fragmentklasse befindet, verwenden Sie:

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

    if(resultCode == Activity.RESULT_OK)
    {
        // If the user had agreed to enabling Bluetooth,
        // populate the ListView with all the paired devices.
        this.arrayDevice = new ArrayAdapter<String>(this.getContext(), R.layout.device_item);
        for(BluetoothDevice bd : this.btService.btAdapater.getBondedDevices())
        {
            this.arrayDevice.add(bd.getAddress());
            this.btDeviceList.setAdapter(this.arrayDevice);
        }
    }
    super.onActivityResult(requestCode, resultCode, data);
}

Fügen Sie einfach den this.variable hinzu, wie im obigen Code gezeigt. Andernfalls wird die Methode in der übergeordneten Aktivität aufgerufen und die Variable der aktuellen Instanz nicht aktualisiert.

Ich habe es auch getestet, indem ich diesen Codeblock in MainActivity eingefügt, this durch die Klasse HomeFragment ersetzt und die Variablen statisch angegeben habe. Ich habe die erwarteten Ergebnisse erzielt.

Wenn Sie also möchten, dass die Fragmentklasse eine eigene Implementierung von onActivityResult hat, ist das obige Codebeispiel die Antwort.

0

Ich habe das Problem behoben, indem ich eine Basisklasse geschrieben habe, die Fragment erweitert, und in onactivityresult der Aktivität das aktuell ausgeführte Fragment mithilfe von fragmenttag identifiziert habe. Dann rufe ich eine benutzerdefinierte Methode in der fragmentbase Klasse auf. Dadurch wird ein Ereignis im aktuell ausgeführten Fragment ausgelöst.

0
Bytecode