किसी गतिविधि से नतीजा पाना

कोई दूसरी गतिविधि शुरू करना. भले ही, वह आपके ऐप्लिकेशन में हो या किसी दूसरी गतिविधि ऐप्लिकेशन, एकतरफ़ा कार्रवाई ज़रूरी नहीं है. कोई गतिविधि शुरू की जा सकती है और उन्हें वापस नतीजे में शामिल किया जा सकता है. उदाहरण के लिए, आपका ऐप्लिकेशन, कैमरा ऐप्लिकेशन शुरू कर सकता है और तो खींची गई फ़ोटो मिल सकती है. या आप Contacts ऐप्लिकेशन चालू कर सकते हैं इस सुविधा का इस्तेमाल करके, उपयोगकर्ता किसी संपर्क को चुनकर, उसे पा सकता है दिखाई गई है.

हालांकि, पहले से मौजूद startActivityForResult() और onActivityResult() एपीआई, Activity क्लास में सभी एपीआई लेवल पर उपलब्ध हैं. Google आपको पूरी जानकारी देता है AndroidX में शुरू किए गए, गतिविधि के नतीजे वाले एपीआई इस्तेमाल करने का सुझाव देता है Activity और Fragment क्लास.

ऐक्टिविटी रिज़ल्ट का एपीआई, नतीजे के लिए रजिस्टर करने के लिए कॉम्पोनेंट उपलब्ध कराता है, नतीजा जनरेट करने वाली गतिविधि को लॉन्च करना और उसके बाद नतीजे को मैनेज करना उसे सिस्टम की मदद से भेजा जाता है.

गतिविधि के किसी नतीजे के लिए कॉलबैक रजिस्टर करें

किसी नतीजे के लिए कोई गतिविधि शुरू करते समय, यह मुमकिन है—और कुछ मामलों में कैमरे के उपयोग जैसी मेमोरी-इंटेंसिव ऑपरेशन के बारे में, यह निश्चित रूप से पता है कि— प्रक्रिया पूरी हो जाएगी और कम मेमोरी की वजह से आपकी गतिविधि खत्म हो जाएगी.

इस वजह से, Activity नतीजे API, नतीजे को अलग कर देते हैं कॉलबैक की सुविधा का इस्तेमाल अपने कोड में उस जगह से करें जहां आपने अन्य गतिविधि लॉन्च की है. क्योंकि नतीजे का कॉलबैक तब उपलब्ध होना चाहिए, जब आपकी प्रोसेस और गतिविधि फिर से बनाया गया, तो कॉलबैक को हर बार बिना किसी शर्त के गतिविधि बनाई जाती है, भले ही दूसरी गतिविधि को लॉन्च करने का आधार सिर्फ़ उपयोगकर्ता इनपुट या अन्य कारोबारी नियम के मुताबिक होता है.

जब ComponentActivity या Fragment, गतिविधि का नतीजा एपीआई, registerForActivityResult() नतीजा कॉलबैक रजिस्टर करने के लिए एपीआई. registerForActivityResult() ने ActivityResultContract और एक ActivityResultCallback और यह ActivityResultLauncher, जिसे अन्य गतिविधि को लॉन्च करने के लिए इस्तेमाल किया जाता है.

ActivityResultContract, नतीजा देने के लिए ज़रूरी इनपुट टाइप के बारे में बताता है के साथ नतीजे के आउटपुट टाइप के साथ. एपीआई से डिफ़ॉल्ट अनुबंध सामान्य कार्रवाइयों के लिए इस्तेमाल किया जा सकता है, जैसे कि तस्वीर लेना, अनुमतियों का अनुरोध करना वगैरह चालू करें. आप यह भी कर सकते हैं पसंद के मुताबिक अनुबंध बनाएं.

ActivityResultCallback एक तरीका वाला इंटरफ़ेस है. onActivityResult() वह तरीका जो ActivityResultContract:

val getContent = registerForActivityResult(GetContent()) { uri: Uri? ->
    // Handle the returned Uri
}

// GetContent creates an ActivityResultLauncher<String> to let you pass
// in the mime type you want to let the user select
ActivityResultLauncher<String> mGetContent = registerForActivityResult(new GetContent(),
    new ActivityResultCallback<Uri>() {
        @Override
        public void onActivityResult(Uri uri) {
            // Handle the returned Uri
        }
});

अगर आपके पास एक से ज़्यादा गतिविधि के नतीजे के लिए कॉल हैं और आपने दो में से किसी एक का इस्तेमाल किया है कॉन्ट्रैक्ट या अलग-अलग कॉलबैक चाहिए, तो registerForActivityResult() को एक से ज़्यादा कॉल करें एक से ज़्यादा ActivityResultLauncher इंस्टेंस रजिस्टर करने के लिए. आपको ऐसा ज़रूर करना चाहिए अपनी प्रत्येक रचना के लिए registerForActivityResult() को एक ही क्रम में कॉल करें खंडित या गतिविधि करनी चाहिए ताकि इनफ़्लाइट परिणाम सही कॉलबैक.

फ़्रैगमेंट या गतिविधि से पहले registerForActivityResult() को कॉल किया जा सकता है बनाया जाता है और मेंबर वैरिएबल का एलान करते समय इसे सीधे इस्तेमाल करने की अनुमति दी जाती है लौटाए गए ActivityResultLauncher इंस्टेंस के लिए.

नतीजे के लिए कोई गतिविधि लॉन्च करें

registerForActivityResult() आपके कॉलबैक को रजिस्टर करता है, लेकिन यह आपके कॉलबैक को रजिस्टर नहीं करता है अन्य गतिविधि लॉन्च करें और नतीजे के लिए अनुरोध करें. इसके बजाय, इस लौटाए गए ActivityResultLauncher इंस्टेंस की ज़िम्मेदारी है.

अगर इनपुट मौजूद है, तो लॉन्चर वह इनपुट लेता है जो ActivityResultContract. कॉल से जुड़ी सुविधा launch() नतीजा तैयार करने की प्रोसेस शुरू करता है. जब उपयोगकर्ता आने वाली गतिविधि और वापस लौटने का समय, onActivityResult() इसके बाद, ActivityResultCallback को एक्ज़ीक्यूट किया जाता है, जैसा कि इस उदाहरण में दिखाया गया है:

val getContent = registerForActivityResult(GetContent()) { uri: Uri? ->
    // Handle the returned Uri
}

override fun onCreate(savedInstanceState: Bundle?) {
    // ...

    val selectButton = findViewById<Button>(R.id.select_button)

    selectButton.setOnClickListener {
        // Pass in the mime type you want to let the user select
        // as the input
        getContent.launch("image/*")
    }
}

ActivityResultLauncher<String> mGetContent = registerForActivityResult(new GetContent(),
    new ActivityResultCallback<Uri>() {
        @Override
        public void onActivityResult(Uri uri) {
            // Handle the returned Uri
        }
});

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    // ...

    Button selectButton = findViewById(R.id.select_button);

    selectButton.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View view) {
            // Pass in the mime type you want to let the user select
            // as the input
            mGetContent.launch("image/*");
        }
    });
}

इसका एक ओवरलोडेड वर्शन launch() की मदद से, ActivityOptionsCompat का इस्तेमाल कर सकते हैं.

गतिविधि का नतीजा किसी अलग क्लास में पाएं

जब ComponentActivity और Fragment क्लास ActivityResultCaller इंटरफ़ेस आपको registerForActivityResult() API का उपयोग करने देता है, तो आप गतिविधि के नतीजे को किसी ऐसी क्लास में पाएं जो लागू नहीं होती ActivityResultCaller का इस्तेमाल करके ActivityResultRegistry सकता है.

उदाहरण के लिए, हो सकता है कि आप LifecycleObserver जो लॉन्चर को लॉन्च करने के साथ ही, कॉन्ट्रैक्ट रजिस्टर करने का काम करती है:

class MyLifecycleObserver(private val registry : ActivityResultRegistry)
        : DefaultLifecycleObserver {
    lateinit var getContent : ActivityResultLauncher<String>

    override fun onCreate(owner: LifecycleOwner) {
        getContent = registry.register("key", owner, GetContent()) { uri ->
            // Handle the returned Uri
        }
    }

    fun selectImage() {
        getContent.launch("image/*")
    }
}

class MyFragment : Fragment() {
    lateinit var observer : MyLifecycleObserver

    override fun onCreate(savedInstanceState: Bundle?) {
        // ...

        observer = MyLifecycleObserver(requireActivity().activityResultRegistry)
        lifecycle.addObserver(observer)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val selectButton = view.findViewById<Button>(R.id.select_button)

        selectButton.setOnClickListener {
            // Open the activity to select an image
            observer.selectImage()
        }
    }
}

class MyLifecycleObserver implements DefaultLifecycleObserver {
    private final ActivityResultRegistry mRegistry;
    private ActivityResultLauncher<String> mGetContent;

    MyLifecycleObserver(@NonNull ActivityResultRegistry registry) {
        mRegistry = registry;
    }

    public void onCreate(@NonNull LifecycleOwner owner) {
        // ...

        mGetContent = mRegistry.register(“key”, owner, new GetContent(),
            new ActivityResultCallback<Uri>() {
                @Override
                public void onActivityResult(Uri uri) {
                    // Handle the returned Uri
                }
            });
    }

    public void selectImage() {
        // Open the activity to select an image
        mGetContent.launch("image/*");
    }
}

class MyFragment extends Fragment {
    private MyLifecycleObserver mObserver;

    @Override
    void onCreate(Bundle savedInstanceState) {
        // ...

        mObserver = new MyLifecycleObserver(requireActivity().getActivityResultRegistry());
        getLifecycle().addObserver(mObserver);
    }

    @Override
    void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        Button selectButton = findViewById(R.id.select_button);
        selectButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View view) {
                mObserver.selectImage();
            }
        });
    }
}

Google का सुझाव है कि आप ActivityResultRegistry एपीआई का इस्तेमाल करते समय ऐसे एपीआई जो अपने-आप LifecycleOwner को LifecycleOwner के रूप में लेते हैं Lifecycle के खत्म होने पर, आपके रजिस्टर किए गए लॉन्चर को हटा देता है. हालांकि, जहां LifecycleOwner उपलब्ध नहीं है, वहां हर एक ActivityResultLauncher क्लास की मदद से, मैन्युअल तरीके से कॉल किया जा सकता है unregister() विकल्प के तौर पर.

टेस्ट

डिफ़ॉल्ट रूप से, registerForActivityResult() अपने-आप ActivityResultRegistry गतिविधि के ज़रिए उपलब्ध कराया जाता है. साथ ही, इस क्षमता के साथ एक ओवरलोड भी हो जाता है, जिसकी वजह से ActivityResultRegistry के अपने इंस्टेंस में जोड़ सकते हैं, जिसे आप किसी अन्य गतिविधि को लॉन्च किए बिना, उसकी गतिविधि के नतीजे वाले कॉल दिखाए जाते हैं.

अपने ऐप्लिकेशन के फ़्रैगमेंट की जांच करते समय, टेस्ट करने के लिए ActivityResultRegistry का इस्तेमाल करें. पास होने के लिए FragmentFactory फ़्रैगमेंट के कंस्ट्रक्टर के लिए ActivityResultRegistry में.

उदाहरण के लिए, ऐसा फ़्रैगमेंट जो पाने के लिए TakePicturePreview कॉन्ट्रैक्ट का इस्तेमाल करता है थंबनेल इमेज में मौजूद टेक्स्ट, नीचे दिए गए टेक्स्ट जैसा हो सकता है:

class MyFragment(
    private val registry: ActivityResultRegistry
) : Fragment() {
    val thumbnailLiveData = MutableLiveData<Bitmap?>

    val takePicture = registerForActivityResult(TakePicturePreview(), registry) {
        bitmap: Bitmap? -> thumbnailLiveData.setValue(bitmap)
    }

    // ...
}

public class MyFragment extends Fragment {
    private final ActivityResultRegistry mRegistry;
    private final MutableLiveData<Bitmap> mThumbnailLiveData = new MutableLiveData();
    private final ActivityResultLauncher<Void> mTakePicture =
        registerForActivityResult(new TakePicturePreview(), mRegistry, new ActivityResultCallback<Bitmap>() {
            @Override
            public void onActivityResult(Bitmap thumbnail) {
                mThumbnailLiveData.setValue(thumbnail);
            }
        });

    public MyFragment(@NonNull ActivityResultRegistry registry) {
        super();
        mRegistry = registry;
    }

    @VisibleForTesting
    @NonNull
    ActivityResultLauncher<Void> getTakePicture() {
        return mTakePicture;
    }

    @VisibleForTesting
    @NonNull
    LiveData<Bitmap> getThumbnailLiveData() {
        return mThumbnailLiveData;
    }

    // ...
}

टेस्ट के लिए खास ActivityResultRegistry बनाते समय, आपको इन चीज़ों को लागू करना होगा यह onLaunch() तरीका. startActivityForResult() को कॉल करने के बजाय, अपना टेस्ट दें लागू करने की प्रोसेस में कॉल कर सकते हैं dispatchResult() इससे आपको ठीक ऐसे नतीजे मिलेंगे जिनका इस्तेमाल आपको अपने टेस्ट में करना है:

val testRegistry = object : ActivityResultRegistry() {
    override fun <I, O> onLaunch(
            requestCode: Int,
            contract: ActivityResultContract<I, O>,
            input: I,
            options: ActivityOptionsCompat?
    ) {
        dispatchResult(requestCode, expectedResult)
    }
}

पूरे टेस्ट से उम्मीद के मुताबिक नतीजा मिलता है और टेस्ट बनाया जाता है ActivityResultRegistry, इसे फ़्रैगमेंट में पास करता है, लॉन्चर को ट्रिगर करता है या तो सीधे तौर पर या Espresso जैसे अन्य टेस्ट एपीआई का इस्तेमाल करके, और फिर पुष्टि करता है नतीजे:

@Test
fun activityResultTest {
    // Create an expected result Bitmap
    val expectedResult = Bitmap.createBitmap(1, 1, Bitmap.Config.RGBA_F16)

    // Create the test ActivityResultRegistry
    val testRegistry = object : ActivityResultRegistry() {
            override fun <I, O> onLaunch(
            requestCode: Int,
            contract: ActivityResultContract<I, O>,
            input: I,
            options: ActivityOptionsCompat?
        ) {
            dispatchResult(requestCode, expectedResult)
        }
    }

    // Use the launchFragmentInContainer method that takes a
    // lambda to construct the Fragment with the testRegistry
    with(launchFragmentInContainer { MyFragment(testRegistry) }) {
            onFragment { fragment ->
                // Trigger the ActivityResultLauncher
                fragment.takePicture()
                // Verify the result is set
                assertThat(fragment.thumbnailLiveData.value)
                        .isSameInstanceAs(expectedResult)
            }
    }
}

पसंद के मुताबिक अनुबंध बनाएं

ActivityResultContracts पर इसमें पहले से बनी कई ActivityResultContract क्लास मौजूद हैं. इनका इस्तेमाल किया जा सकता है आपको अपने अनुबंध से जुड़े सटीक टाइप-सेफ़ एपीआई उपलब्ध कराने होंगे.

हर ActivityResultContract में, पहले से तय इनपुट और आउटपुट क्लास की ज़रूरत होती है, Void को इनपुट टाइप के तौर पर इस्तेमाल करके, अगर आपने उसे किसी इनपुट की ज़रूरत नहीं है (Kotlin की मदद से, Void? या Unit का इस्तेमाल करें).

हर अनुबंध में createIntent() तरीका, जो Context और इनपुट को लेकर Intent को बनाता है का इस्तेमाल किया गया है startActivityForResult() के साथ.

हर कानूनी समझौते को parseResult(), जो दिए गए resultCode से आउटपुट देता है, जैसे Activity.RESULT_OK या Activity.RESULT_CANCELED और Intent.

कानूनी समझौते को वैकल्पिक तौर पर लागू किया जा सकता है getSynchronousResult() अगर दिए गए इनपुट के बिना नतीजे तय किए जा सकते हैं createIntent() को कॉल करने, अन्य गतिविधि शुरू करने, और इसका इस्तेमाल करने की ज़रूरत नहीं है नतीजा बनाने के लिए parseResult().

नीचे दिए गए उदाहरण में, ActivityResultContract बनाने का तरीका बताया गया है:

class PickRingtone : ActivityResultContract<Int, Uri?>() {
    override fun createIntent(context: Context, ringtoneType: Int) =
        Intent(RingtoneManager.ACTION_RINGTONE_PICKER).apply {
            putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, ringtoneType)
        }

    override fun parseResult(resultCode: Int, result: Intent?) : Uri? {
        if (resultCode != Activity.RESULT_OK) {
            return null
        }
        return result?.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI)
    }
}

public class PickRingtone extends ActivityResultContract<Integer, Uri> {
    @NonNull
    @Override
    public Intent createIntent(@NonNull Context context, @NonNull Integer ringtoneType) {
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
        intent.putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, ringtoneType.intValue());
        return intent;
    }

    @Override
    public Uri parseResult(int resultCode, @Nullable Intent result) {
        if (resultCode != Activity.RESULT_OK || result == null) {
            return null;
        }
        return result.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI);
    }
}

अगर आपको कस्टम अनुबंध की ज़रूरत नहीं है, तो StartActivityForResult कानूनी समझौता. यह एक सामान्य कॉन्ट्रैक्ट है, जिसमें किसी भी Intent को इनपुट के तौर पर लिया जाता है और नतीजे के तौर पर ActivityResult, आपको अपने कॉलबैक में resultCode और Intent को एक्सट्रैक्ट करने की सुविधा देता है, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

val startForResult = registerForActivityResult(StartActivityForResult()) { result: ActivityResult ->
    if (result.resultCode == Activity.RESULT_OK) {
        val intent = result.data
        // Handle the Intent
    }
}

override fun onCreate(savedInstanceState: Bundle) {
    // ...

    val startButton = findViewById(R.id.start_button)

    startButton.setOnClickListener {
        // Use the Kotlin extension in activity-ktx
        // passing it the Intent you want to start
        startForResult.launch(Intent(this, ResultProducingActivity::class.java))
    }
}

ActivityResultLauncher<Intent> mStartForResult = registerForActivityResult(new StartActivityForResult(),
        new ActivityResultCallback<ActivityResult>() {
    @Override
    public void onActivityResult(ActivityResult result) {
        if (result.getResultCode() == Activity.RESULT_OK) {
            Intent intent = result.getData();
            // Handle the Intent
        }
    }
});

@Override
public void onCreate(@Nullable savedInstanceState: Bundle) {
    // ...

    Button startButton = findViewById(R.id.start_button);

    startButton.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View view) {
            // The launcher with the Intent you want to start
            mStartForResult.launch(new Intent(this, ResultProducingActivity.class));
        }
    });
}