onActivityResult n'est pas appelé dans Fragment
L'activité hébergeant ce fragment a sa onActivityResult appelée au retour de l'activité de la caméra.
Mon fragment commence une activité pour un résultat avec l'intention envoyée à l'appareil photo de prendre une photo. L'application Image se charge très bien, prend une photo et revient. La onActivityResult n'est cependant jamais touchée. J'ai défini des points d'arrêt, mais rien n'est déclenché. Un fragment peut-il avoir onActivityResult? Je pense que oui puisque c'est une fonction fournie. Pourquoi cela n'est-il pas déclenché?
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);
}
}
L’activité d’hébergement a priorité sur onActivityResult(), mais elle n’a pas fait appel à super.onActivityResult() pour les codes de résultat non gérés. Apparemment, même si le fragment est celui qui appelle startActivityForResult(), l'activité est la première à traiter le résultat. Cela a du sens quand on considère la modularité des fragments. Une fois que j’ai implémenté super.onActivityResult() pour tous les résultats non gérés, le fragment a eu l’opportunité de gérer le résultat.
Et aussi de @siqing répondre:
Pour obtenir le résultat dans votre fragment, appelez startActivityForResult(intent,111); au lieu de getActivity().startActivityForResult(intent,111); dans votre fragment.
Je pense que vous avez appelé getActivity().startActivityForResult(intent,111);. Vous devriez appeler startActivityForResult(intent,111);.
Option 1:
Si vous appelez startActivityForResult() à partir du fragment, vous devez appeler startActivityForResult() et non pas getActivity().startActivityForResult(), car cela produira un fragment onActivityResult ().
Si vous ne savez pas exactement où vous appelez sur startActivityForResult() et comment vous allez appeler des méthodes.
Option 2:
Puisque Activity obtient le résultat de onActivityResult(), vous devez remplacer le onActivityResult() de l'activité et appeler super.onActivityResult() pour se propager au fragment correspondant pour les codes de résultats non gérés ou pour tous.
Si les deux options ci-dessus ne fonctionnent pas, reportez-vous à l'option 3 car elle fonctionnera définitivement.
Option 3:
Un appel explicite de fragment à la fonction onActivityResult est le suivant.
Dans la classe Activité parent, remplacez la méthode onActivityResult () et même la même chose dans la classe Fragment et appelez-la comme code suivant.
Dans la classe parente:
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.dualPane);
fragment.onActivityResult(requestCode, resultCode, data);
}
Dans la classe enfant:
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// In fragment class callback
}
J'ai le même problème avec le ChildFragmentManager. Le gestionnaire ne transmettra pas le résultat au fragment imbriqué, vous devez le faire manuellement dans votre fragment de 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);
}
}
Si vous ne connaissez pas les fragments de votre activité, il suffit de les énumérer et d'envoyer les arguments de résultat d'activité:
// 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);
}
}
FragmentActivity remplace requestCode par un nom modifié. Ensuite, lorsque onActivityResult() sera appelé, FragmentActivity analyse les 16 bits les plus élevés et restaure l'index du fragment d'origine. Regardez ce schéma:
Si vous avez quelques fragments au niveau racine, il n'y a pas de problèmes. Mais si vous avez des fragments imbriqués , par exemple Fragment avec quelques onglets à l'intérieur de ViewPager, vous garanti sera confronté à un problème (ou y a déjà fait face).
Parce que , un seul index est stocké à l'intérieur de requestCode. C'est l'index de Fragment à l'intérieur de son FragmentManager. Lorsque nous utilisons des fragments imbriqués, il existe des enfants FragmentManagers, qui ont leur propre liste de fragments. Il est donc nécessaire de sauvegarder toute la chaîne d’index, à partir de la racine FragmentManager.
Comment résoudre ce problème? Il existe une solution commune pour contourner le problème dans cet article .
C'est l'un des problèmes les plus populaires. Nous pouvons trouver beaucoup de discussions sur ce problème. Mais aucun d'entre eux n'est utile pour moi.
J'ai donc résolu ce problème en utilisant cette solution.
Comprenons d'abord pourquoi cela se produit.
Nous pouvons appeler startActivityForResult directement à partir de Fragment mais, en réalité, les mécanismes derrière sont tous traités par activité.
Une fois que vous appelez startActivityForResult depuis un fragment, requestCode sera modifié pour attacher l'identité du fragment au code. Cela permettra à Activity de retracer ceux qui envoient cette demande une fois le résultat reçu.
Une fois l'activité retrouvée, le résultat sera envoyé à onActivityResult d'Activity avec le requestCode modifié qui sera décodé en identifiant le requestCode + identité d'origine du fragment. Après cela, Activity enverra le résultat de l'activité à ce fragment via onActivityResult. Et tout est fait.
Le problème est:
Activity peut envoyer le résultat uniquement au fragment qui a été attaché directement à Activity mais pas au fragment imbriqué. C'est la raison pour laquelle onActivityResult of fragment imbriqué n'a jamais été appelé, quoi qu'il arrive.
Solution:
1) Commencez l’intention dans votre fragment par le code ci-dessous:
/** Pass your fragment reference **/
frag.startActivityForResult(intent, REQUEST_CODE); // REQUEST_CODE = 12345
2) Dans votre activité parent, remplacez ** onActivityResult(): **
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
}
Vous devez appeler cela dans l'activité parent pour que cela fonctionne.
) Dans votre fragment appel:
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (resultCode == Activity.RESULT_OK) {
}
}
C'est ça. Avec cette solution, il pourrait être appliqué à n'importe quel fragment, qu'il soit imbriqué ou non. Et oui, cela couvre aussi tous les cas! De plus, les codes sont aussi gentils et propres.
POUR DE NOMBREUX FRAGMENTS CONSACRÉS (par exemple, lors de l'utilisation d'un ViewPager dans un fragment)
dans votre activité principale:
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
}
Dans votre fragment:
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
for (Fragment fragment : getChildFragmentManager().getFragments()) {
fragment.onActivityResult(requestCode, resultCode, data);
}
}
Dans votre fragment imbriqué
Activité d'appel
getParentFragment().startActivityForResult(intent, uniqueInstanceInt);
uniqueInstanceInt - remplacez-le par un entier unique parmi les fragments imbriqués afin d'éviter qu'un autre fragment ne traite la réponse.
Recevoir une réponse
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == uniqueInstanceInt ) {
// TODO your code
}
}
Attention
Un nombre compris entre 0 et 65536 doit être utilisé dans uniqueInstanceInt pour éviter les erreurs "Ne peut utiliser que les 16 bits inférieurs pour le code de requête".
Je peux ajouter deux conseils si quelqu'un ne peut toujours pas le faire. Dans le fichier Manifest.xml, assurez-vous que l'activité d'hébergement ne s'est pas terminée au rappel et que l'activité à démarrer a le mode de lancement par défaut. Voir les détails ci-dessous:
Pour l'activité Hébergement, définissez la propriété no history sur false si have
Android:noHistory="false"
Pour que l’activité démarre, définissez le mode de lancement en standard si
Android:launchMode="standard"
Je faisais également face au même problème une fois que j'ai déplacé ce bloc de code en dehors d'un fragment vers une classe d'utilitaire , avec parentActivity passé en tant qu'argument ,
Intent intent = new Intent(parentActivity, CameraCaptureActivity.class);
parentActivity.startActivityForResult(intent,requestCode);
Ensuite, je n’obtenais aucune valeur dans la méthode onActivityResult de cette méthode fragment, Après, j’ai modifié l’argument en Fragment, donc la définition révisée de la méthode ressemblait à ceci:
Intent intent = new Intent(fragment.getContext(), CameraCaptureActivity.class);
fragment.startActivityForResult(intent,requestCode);
Après cela, j'ai pu obtenir de la valeur dans onActivityResult sur le Fragment
J'ai aussi rencontré ce problème dans un fragment. Et j'ai appelé startActivityForResult dans un DialogFragment.
Mais maintenant, ce problème a été résolu: FragmentClassname.this.startActivityForResult.
Solution 1:
Appelez startActivityForResult(intent, REQUEST_CODE); au lieu de getActivity().startActivityForResult(intent, REQUEST_CODE);.
Solution 2:
Lorsque startActivityForResult(intent, REQUEST_CODE); est appelée, onActivityResult(requestCode,resultcode,intent) de l'activité est appelée et vous pouvez ensuite appeler fragments onActivityResult() à partir de là, en passant le requestCode, resultCode and intent.
Dans mon cas, c’était un bogue Android ( http://technet.weblineindia.com/mobile/onactivityresult-not-getting-called-in-nested-fragments-Android/ ), si vous utilisez FragmentActivity pris en charge, vous devez utiliser getSupportFragmentManager au lieu de getChildFragmentManager:
List<Fragment> fragments = getSupportFragmentManager().getFragments();
if (fragments != null) {
for (Fragment fragment : fragments) {
if(fragment instanceof UserProfileFragment) {
fragment.onActivityResult(requestCode, resultCode, data);
}
}
}
POUR LES FRAGMENTS INTÉGRÉS (par exemple, lors de l'utilisation d'un ViewPager)
Dans votre activité principale:
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
}
Dans votre fragment de niveau supérieur principal (fragment 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);
}
Dans YourFragment (fragment imbriqué):
public void yourMethod(Intent data){
// Do whatever you want with your data
}
Dans votre fragment, appelez
this.startActivityForResult(intent, REQUEST_CODE);
où this fait référence au fragment. Sinon, faites comme @Clevester a dit:
Fragment fragment = this;
....
fragment.startActivityForResult(intent, REQUEST_CODE);
J'ai aussi dû appeler
super.onActivityResult(requestCode, resultCode, data);
dans onActivityResult de l'activité parente pour le faire fonctionner.
(J'ai adapté cette réponse à partir de la réponse de @ Clevester.)
En bref,
Dans le fragment, déclarez Fragment fragment = this;
après cela, utilisez fragment.startActivityForResult.
Le résultat reviendra dans activityResult.
La plupart de ces réponses continuent de dire que vous devez appeler super.onActivityResult(...) dans votre hôte Activity pour votre Fragment. Mais cela n'a pas semblé fonctionner pour moi.
Ainsi, dans votre hôte Activity, vous devez appeler votre FragmentsonActivityResult(...). Voici un exemple.
public class HostActivity extends Activity {
private MyFragment myFragment;
protected void onActivityResult(...) {
super.onActivityResult(...);
this.myFragment.onActivityResult(...);
}
}
À un moment donné dans votre HostActivity, vous devrez attribuer this.myFragment le Fragment que vous utilisez. Ou bien, utilisez FragmentManager pour obtenir le Fragment au lieu de garder une référence à celui-ci dans votre HostActivity. Vérifiez également que null avant d'essayer d'appeler la 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);
}
}
Vous pouvez simplement remplacer BaseActivity
onActivityResultsur le fragmentbaseActivity.startActivityForResult.Sur BaseActivity, ajoutez une interface et remplacez 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); }On Fragment implémente
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(); } }
Cette solution de contournement fera l'affaire.
Si le problème ci-dessus est rencontré à identifiant Facebook, vous pouvez utiliser le code ci-dessous dans une activité parent de votre fragment, telle que:
Fragment fragment = getFragmentManager().findFragmentById(Android.R.id.tabcontent);
fragment.onActivityResult(requestCode, resultCode, data);
ou:
Fragment fragment = getFragmentManager().findFragmentById("fragment id here");
fragment.onActivityResult(requestCode, resultCode, data);
Et ajoutez l'appel ci-dessous dans votre fragment ...
callbackManager.onActivityResult(requestCode, resultCode, data);
Mon problème était lié à l'activité de l'hôte. Je l'ai trouvé avec un ensemble Android:launchMode="standard" je l'ai supprimé temporairement et il fonctionne!
Si vous utilisez des fragments imbriqués, cela fonctionne également:
getParentFragment().startActivityForResult(intent, RequestCode);
De plus, vous devez appeler super.onActivityResult à partir de l'activité parent et renseigner la méthode onActivityResult du fragment.
Votre code a un fragment imbriqué. L'appel de super.onActivityForResult ne fonctionne pas
Vous ne voulez pas modifier chaque activité à partir de laquelle votre fragment peut être appelé et ne travaillez pas avec l'appel de chaque fragment de la chaîne de fragments.
Voici l'une des nombreuses solutions de travail. créez un fragment à la volée et connectez-le directement à l'activité avec le gestionnaire de fragments de support. Appelez ensuite startActivityForResult à partir du fragment nouvellement créé.
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();
}
Je soupçonne fort que toutes les réponses ici ne sont que des hacks. Je les ai tous essayés et beaucoup d'autres, mais sans conclusion fiable, car il y a toujours une sorte de problème stupide. Pour ma part, je ne peux pas compter sur des résultats incohérents. Si vous consultez la documentation officielle de l'API Android pour Fragments, vous verrez que Google indique clairement ce qui suit:
Appelez startActivityForResult (Intent, int) à partir du fragment contenant l'activité.
Voir: Android Fragment API
Donc, il semblerait que l’approche la plus correcte et la plus fiable serait d’appeler startActivityForResult () à partir de l’hébergement et de gérer également le résultat onActivityResult () à partir de là.
Comme mentionné par Ollie C, il existe un bogue actif pour la bibliothèque de support utilisant les valeurs renvoyées à onActivityResult lorsque vous utilisez des fragments imbriqués. Je viens de frapper : .
Voir --- (Fragment.onActivityResult non appelé lorsque requestCode! =.
Je viens de faire une méthode de contournement:
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);
}
Dans votre fragment, avant startActivityResult, définissez
MainActivity._tempFragment = this;
Après onActivityResult <- in Fragment
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
// Do your job
{
}
MainActivity._tempFragment = null;
}
Un autre cas d’utilisation non décrit dans d’autres réponses:
onActivityResult() déclaré dans le fragment n'est pas appelé lors de l'utilisation de exception.startResolutionForResult():
if (exception is ResolvableApiException) {
exception.startResolutionForResult(activity!!, MY_REQUEST_CODE)
}
Dans ce cas, remplacez exception.startResolutionForResult() par le startIntentSenderForResult() du fragment:
if (exception is ResolvableApiException) {
startIntentSenderForResult(exception.resolution.intentSender, MY_REQUEST_CODE, null, 0, 0, 0, null)
}
Utilisez simplement le code ci-dessous pour le 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 appellera sans appeler son parent.
Une des méthodes les plus simples consiste à démarrer une activité à partir de votre fragment.
startActivity(ActivityName);
Ensuite, ajoutez votre appel startActivityForResult(intent,"1"); à partir de votre activité et ajoutez onActivityResult à votre activité.
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.
}
Version Kotlin (Dans votre activité 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)
}
}
Un point sur lequel personne n'a
mentionet qui s'assure que votre activité hôte mode de lancement ne doit pas être défini sursingleInstancenisingleTask.
onActivityResult ne fonctionnera pas si votre mode de lancement est défini sur SingleInstance ou SingleTask. ou vous appelez votre activité avec ces IntentFilters
standard ou singleTop le mode de lancement fonctionnera correctement.
S'il y a un problème avec la méthode onActivityResult qui se trouve dans la classe fragment et que vous souhaitez mettre à jour quelque chose qui se trouve également dans la classe fragment, utilisez:
@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);
}
Ajoutez simplement le this.variable comme indiqué dans le code ci-dessus. Sinon, la méthode sera appelée dans l'activité parente et la variable ne sera pas mise à jour de l'instance actuelle.
Je l'ai également testé en plaçant ce bloc de code dans la MainActivity, en remplaçant this par la classe HomeFragment et en ayant les variables statiques. J'ai eu des résultats comme je m'y attendais.
Donc, si vous voulez que la classe fragment ait sa propre implémentation de onActivityResult, l'exemple de code ci-dessus est la solution.
J'ai traité le problème en écrivant une classe de base qui étend Fragment, et dans onactivityresult de l'activité, j'ai identifié le fragment en cours d'exécution à l'aide de fragmenttag. Ensuite, j'appelle une méthode définie par l'utilisateur dans la classe fragmentbase. Cela déclenchera un événement dans le fragment en cours d'exécution.