Android
इरादा

परिचय

वाक्य - विन्यास

• आशय इरादे ()
• आशय इरादे (इरादे इरादे)
• आशय इरादे (स्ट्रिंग कार्रवाई)
• आशय इरादे (स्ट्रिंग एक्शन, उड़ी उड़ी)
• आशय इरादे (संदर्भ पैकेज कॉन्टेक्स्ट, क्लास <?> Cls)
• आशय इरादे (स्ट्रिंग एक्शन, उड़ी उड़ी, संदर्भ पैकेज कॉन्टेक्स्ट, क्लास <?> Cls?
• शून्य शुरुआत (इरादे इरादे)
• शून्य शुरुआत (इरादे इरादे, बंडल विकल्प)
• शून्य startActivityForResult (इरादे इरादे, इंट अनुरोध)
• शून्य startActivityForResult (इरादे इरादे, int अनुरोधकोड, बंडल विकल्प)
• आशय putExtra (स्ट्रिंग नाम, डबल [] मूल्य)
• आशय putExtra (स्ट्रिंग नाम, इंट वैल्यू)
• आशय putExtra (स्ट्रिंग नाम, चारसमानता मूल्य)
• आशय putExtra (स्ट्रिंग नाम, चार मूल्य)
• आशय putExtra (स्ट्रिंग नाम, बंडल मान)
• आशय putExtra (स्ट्रिंग नाम, पार्सलेबल [] मान)
• आशय putExtra (स्ट्रिंग नाम, सीरियल मूल्य)
• आशय putExtra (स्ट्रिंग नाम, int [] मूल्य)
• आशय putExtra (स्ट्रिंग नाम, फ्लोट मान)
• आशय putExtra (स्ट्रिंग नाम, बाइट [मूल्य]
• आशय putExtra (स्ट्रिंग नाम, लंबे [] मूल्य)
• आशय putExtra (स्ट्रिंग नाम, पार्सल मूल्य)
• आशय putExtra (स्ट्रिंग नाम, फ्लोट [] मूल्य)
• आशय putExtra (स्ट्रिंग नाम, लंबे मूल्य)
• आशय putExtra (स्ट्रिंग नाम, स्ट्रिंग [] मान)
• आशय putExtra (स्ट्रिंग नाम, बूलियन मान)
• आशय putExtra (स्ट्रिंग नाम, बूलियन [] मूल्य)
• आशय putExtra (स्ट्रिंग नाम, छोटा मान)
• आशय putExtra (स्ट्रिंग नाम, डबल मान)
• आशय putExtra (स्ट्रिंग नाम, संक्षिप्त [] मूल्य)
• आशय putExtra (स्ट्रिंग नाम, स्ट्रिंग मान)
• आशय putExtra (स्ट्रिंग नाम, बाइट मान)
• आशय putExtra (स्ट्रिंग नाम, चार [मूल्य]
• आशय putExtra (स्ट्रिंग नाम, CharSequence [] मूल्य)

पैरामीटर

टिप्पणियों

PackageManager pm = getActivity().getPackageManager();
if (intent.resolveActivity(pm) != null) {
    //intent can be handled
    startActivity(intent);
} else {
     //intent can not be handled
}

एक गतिविधि शुरू करें

यह उदाहरण OriginActivity से DestinationActivity शुरू करेगा।

यहां, Intent कंस्ट्रक्टर दो पैरामीटर लेता है:

1. एक प्रसंग इसके पहले पैरामीटर के रूप में (इसका उपयोग इसलिए किया जाता है क्योंकि गतिविधि वर्ग प्रसंग का उपवर्ग है)
2. एप्लिकेशन घटक का वर्ग जिसमें सिस्टम को इंटेंट वितरित करना चाहिए (इस मामले में, जो गतिविधि शुरू होनी चाहिए)

public class OriginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);

        Intent intent = new Intent(this, DestinationActivity.class);
        
        startActivity(intent);
        finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity again.
    }
}

बनाने के लिए एक और तरीका है Intent खुला करने के लिए DestinationActivity के लिए डिफ़ॉल्ट निर्माता का उपयोग है Intent , और प्रयोग setClass() विधि इसे खोलने के लिए जो गतिविधि बताने के लिए:

Intent i=new Intent();
i.setClass(this, DestinationActivity.class);
startActivity(intent);
finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity 

गतिविधियों के बीच डेटा पास करना

यह उदाहरण एक भेजने दिखाता String के रूप में मूल्य के साथ "Some data!" OriginActivity से DestinationActivity ।

नोट: यह दो गतिविधियों के बीच डेटा भेजने का सबसे सीधा तरीका है। अधिक मजबूत कार्यान्वयन के लिए स्टार्टर पैटर्न का उपयोग करने पर उदाहरण देखें।

OriginActivity

public class OriginActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);
        
        // Create a new Intent object, containing DestinationActivity as target Activity.
        final Intent intent = new Intent(this, DestinationActivity.class);

        // Add data in the form of key/value pairs to the intent object by using putExtra()
        intent.putExtra(DestinationActivity.EXTRA_DATA, "Some data!");

        // Start the target Activity with the intent object
        startActivity(intent);
    }
} 

DestinationActivity

public class DestinationActivity extends AppCompatActivity {

    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_destination);

        // getIntent() returns the Intent object which was used to start this Activity
        final Intent intent = getIntent();

        // Retrieve the data from the intent object by using the same key that
        // was previously used to add data to the intent object in OriginActivity.
        final String data = intent.getStringExtra(EXTRA_DATA);
    }
}

अन्य primitive डेटा प्रकारों के साथ-साथ arrays , Bundle और Parcelable डेटा को भी पास करना संभव है। Serializable करना भी संभव है, लेकिन इससे बचना चाहिए क्योंकि यह Parcelable तुलना में तीन गुना अधिक Parcelable ।

Serializable एक मानक जावा interface । आप बस एक वर्ग को Serializable interface रूप में लागू करके Serializable रूप में चिह्नित करते हैं और जावा आवश्यक स्थितियों के दौरान स्वचालित रूप से इसे क्रमबद्ध करेगा।

Parcelable एक एंड्रॉइड विशिष्ट interface जिसे कस्टम डेटा प्रकारों पर लागू किया जा सकता है (अर्थात आपकी स्वयं की वस्तुएं / POJO ऑब्जेक्ट), यह आपकी ऑब्जेक्ट को चपटा करने और कुछ भी करने की आवश्यकता के बिना गंतव्य को फिर से संगठित करने की अनुमति देता है। एक वस्तु को पार्सल करने का एक दस्तावेजी उदाहरण है।

एक बार आपके पास एक parcelable वस्तु होने के बाद आप इसे आद्य वस्तु के साथ एक आदिम प्रकार की तरह भेज सकते हैं:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

या एक बंडल में / एक टुकड़े के लिए एक तर्क के रूप में:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

और फिर इसे getParcelableExtra का उपयोग करके गंतव्य पर इरादे से पढ़ें:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

या बंडल से टुकड़े में पढ़ते समय:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

एक बार आपके पास एक Serializable वस्तु होने के बाद आप इसे एक इरादे में रख सकते हैं:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

और फिर इसे गंतव्य स्थान पर आशय वस्तु से भी पढ़ें जैसा कि नीचे दिखाया गया है:

final SerializableType data = (SerializableType)bundle.getSerializable(EXTRA_DATA); 

ई - मेल भेज रहा हूँ

// Compile a Uri with the 'mailto' schema
Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
        "mailto","[email protected]", null));
// Subject
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Hello World!");
// Body of email
emailIntent.putExtra(Intent.EXTRA_TEXT, "Hi! I am sending you a test email.");
// File attachment
emailIntent.putExtra(Intent.EXTRA_STREAM, attachedFileUri);

// Check if the device has an email client
if (emailIntent.resolveActivity(getPackageManager()) != null) {
     // Prompt the user to select a mail app
     startActivity(Intent.createChooser(emailIntent,"Choose your mail application"));
} else {
    // Inform the user that no email clients are installed or provide an alternative
}

यह उपयोगकर्ता की पसंद के मेल ऐप में एक ईमेल भर देगा।

आप इसे एक अनुलग्नक जोड़ने की जरूरत है, तो आप उपयोग कर सकते हैं Intent.ACTION_SEND बजाय Intent.ACTION_SENDTO । कई अनुलग्नकों के लिए आप ACTION_SEND_MULTIPLE उपयोग कर सकते हैं

सावधानी का एक शब्द है: नहीं हर डिवाइस के लिए एक प्रदाता है ACTION_SENDTO आह्वान करने और startActivity() के साथ की जाँच के बिना resolveActivity() पहले एक ActivityNotFoundException फेंक सकता है।

किसी अन्य गतिविधि से परिणाम प्राप्त करना

startActivityForResult(Intent intent, int requestCode) का उपयोग करके आप एक और Activity शुरू कर सकते हैं और फिर उस Activity परिणाम onActivityResult(int requestCode, int resultCode, Intent data) विधि से प्राप्त कर सकते हैं। परिणाम एक Intent रूप में वापस आ जाएगा। एक आशय में बंडल के माध्यम से डेटा हो सकता है

इस उदाहरण में MainActivity एक DetailActivity शुरू DetailActivity और फिर DetailActivity एक परिणाम की उम्मीद DetailActivity । प्रत्येक अनुरोध प्रकार अपनी ही होनी चाहिए int अनुरोध कोड, ताकि ओवरराइड में onActivityResult(int requestCode, int resultCode, Intent data) में विधि MainActivity , यह के मूल्यों की तुलना द्वारा जो अनुरोध प्रक्रिया के लिए निर्धारित किया जा सकता requestCode और REQUEST_CODE_EXAMPLE (हालांकि इस में उदाहरण, केवल एक ही है)।

मुख्य गतिविधि:

public class MainActivity extends Activity {

    // Use a unique request code for each use case 
    private static final int REQUEST_CODE_EXAMPLE = 0x9345; 

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Create a new instance of Intent to start DetailActivity
        final Intent intent = new Intent(this, DetailActivity.class);

        // Start DetailActivity with the request code
        startActivityForResult(intent, REQUEST_CODE_EXAMPLE);
    }

    // onActivityResult only get called 
    // when the other Activity previously started using startActivityForResult
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // First we need to check if the requestCode matches the one we used.
        if(requestCode == REQUEST_CODE_EXAMPLE) {

            // The resultCode is set by the DetailActivity
            // By convention RESULT_OK means that whatever
            // DetailActivity did was executed successfully
            if(resultCode == Activity.RESULT_OK) {
                // Get the result from the returned Intent
                final String result = data.getStringExtra(DetailActivity.EXTRA_DATA);

                // Use the data - in this case, display it in a Toast.
                Toast.makeText(this, "Result: " + result, Toast.LENGTH_LONG).show();
            } else {
                // setResult wasn't successfully executed by DetailActivity 
                // Due to some error or flow of control. No data to retrieve.
            }
        }
    }
}

DetailActivity:

public class DetailActivity extends Activity {

    // Constant used to identify data sent between Activities.
    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);

        final Button button = (Button) findViewById(R.id.button);
        // When this button is clicked we want to return a result
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // Create a new Intent object as container for the result
                final Intent data = new Intent();

                // Add the required data to be returned to the MainActivity
                data.putExtra(EXTRA_DATA, "Some interesting data!");
                
                // Set the resultCode as Activity.RESULT_OK to 
                // indicate a success and attach the Intent
                // which contains our result data
                setResult(Activity.RESULT_OK, data); 

                // With finish() we close the DetailActivity to 
                // return back to MainActivity
                finish();
            }
        });
    }

    @Override
    public void onBackPressed() {
        // When the user hits the back button set the resultCode 
        // as Activity.RESULT_CANCELED to indicate a failure
        setResult(Activity.RESULT_CANCELED);
        super.onBackPressed();
    }
}

कुछ बातों से आपको अवगत होना चाहिए:

• एक बार जब आप कॉल finish() कर लेते हैं तो डेटा केवल वापस आ जाता है। आपको कॉल finish() होने से पहले setResult() कॉल करने की आवश्यकता है, अन्यथा, कोई भी परिणाम वापस नहीं किया जाएगा।

• सुनिश्चित करें कि आपकी Activity android:launchMode="singleTask" का उपयोग नहीं कर रही है android:launchMode="singleTask" , या यह Activity को एक अलग कार्य में चलाने का कारण बनेगा और इसलिए आपको इसका परिणाम प्राप्त नहीं होगा। यदि आपकी Activity लॉन्च मोड के रूप में singleTask का उपयोग singleTask है, तो यह तुरंत Activity.RESULT_CANCELED परिणाम कोड के साथ onActivityResult() कॉल करेगा।

• android:launchMode="singleInstance" का उपयोग करते समय सावधान रहें android:launchMode="singleInstance" । लॉलीपॉप (एंड्रॉइड 5.0, एपीआई स्तर 21) से पहले उपकरणों पर, गतिविधियां परिणाम नहीं लौटाएंगी।

• जब आप startActivityForResult() कॉल करते हैं, तो आप स्पष्ट या अंतर्निहित इंट्रेंट का उपयोग कर सकते हैं। परिणाम प्राप्त करने के लिए अपनी खुद की गतिविधियों में से एक शुरू करते समय, आपको यह सुनिश्चित करने के लिए एक स्पष्ट इरादे का उपयोग करना चाहिए कि आप अपेक्षित परिणाम प्राप्त करते हैं। एक स्पष्ट intent हमेशा अपने लक्ष्य तक पहुंचाया जाता है, चाहे उसमें कोई भी हो; filter से परामर्श नहीं किया जाता है। लेकिन एक अंतर्निहित इरादे को केवल एक घटक तक पहुंचाया जाता है, अगर यह घटक के किसी एक फिल्टर से गुजर सकता है।

एक ब्राउज़र में एक URL खोलें

डिफ़ॉल्ट ब्राउज़र के साथ खोलना

यह उदाहरण दिखाता है कि आप अपने एप्लिकेशन के बजाय अंतर्निहित वेब ब्राउज़र में प्रोग्रामेटिक रूप से एक URL कैसे खोल सकते हैं। यह आपके एप्लिकेशन को आपकी प्रकट फ़ाइल में INTERNET अनुमति शामिल करने की आवश्यकता के बिना एक वेबपेज खोलने की अनुमति देता है।

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    // Verify that the intent will resolve to an activity
    if (intent.resolveActivity(getPackageManager()) != null) {
        // Here we use an intent without a Chooser unlike the next example
        startActivity(intent);
    } 
}

ब्राउज़र का चयन करने के लिए उपयोगकर्ता को प्रेरित करना

ध्यान दें कि यह उदाहरण Intent.createChooser() विधि का उपयोग करता है:

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
    // Note the Chooser below. If no applications match, 
    // Android displays a system message.So here there is no need for try-catch.
    startActivity(Intent.createChooser(intent, "Browse with"));
   
}

कुछ मामलों में, URL "www" से शुरू हो सकता है। अगर ऐसा है तो आपको यह अपवाद मिलेगा:

android.content.ActivityNotFoundException : इरादे को संभालने के लिए कोई गतिविधि नहीं मिली

URL को हमेशा "http: //" या "https: //" से शुरू करना चाहिए। इसलिए आपके कोड को इसकी जांच करनी चाहिए, जैसा कि निम्नलिखित कोड स्निपेट में दिखाया गया है:

if (!url.startsWith("https://") && !url.startsWith("http://")){
    url = "http://" + url;
}
Intent openUrlIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
if (openUrlIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(openUrlIntent);
} 

सर्वोत्तम प्रथाएं

जांचें कि क्या डिवाइस पर कोई एप्लिकेशन नहीं हैं जो अंतर्निहित इरादे प्राप्त कर सकते हैं। अन्यथा, जब यह startActivity() कहता है, तो आपका ऐप क्रैश हो जाएगा। पहले यह सत्यापित करने के लिए कि कोई ऐप आशय प्राप्त करने के लिए मौजूद है, अपने इंटेंट ऑब्जेक्ट पर resolveActivity() को कॉल करें। यदि परिणाम गैर-अशक्त है, तो कम से कम एक ऐप है जो इरादे को संभाल सकता है और startActivity() को कॉल करना सुरक्षित है। यदि परिणाम शून्य है, तो आपको इरादे का उपयोग नहीं करना चाहिए और यदि संभव हो, तो आपको उस विशेषता को अक्षम करना चाहिए जो इरादे को आमंत्रित करता है।

एक गतिविधि स्टैक साफ़ करना

कभी-कभी आप पिछले स्टैक से पिछली गतिविधियों को हटाते समय एक नई गतिविधि शुरू करना चाहते हैं, इसलिए बैक बटन आपको वापस उनके पास नहीं ले जाता है। इसका एक उदाहरण लॉगिन गतिविधि पर एक ऐप शुरू करना हो सकता है, जो आपको अपने आवेदन की मुख्य गतिविधि के माध्यम से ले जाएगा, लेकिन लॉग आउट करने पर आप वापस जाने का मौका दिए बिना लॉगिन पर वापस निर्देशित होना चाहते हैं। इस तरह के मामले में आप आशय के लिए FLAG_ACTIVITY_CLEAR_TOP ध्वज सेट कर सकते हैं, जिसका अर्थ है कि यदि चालू की जा रही गतिविधि पहले से ही वर्तमान कार्य (LoginActivity) में चल रही है, तो उस गतिविधि का एक नया उदाहरण लॉन्च करने के बजाय, अन्य सभी गतिविधियाँ शीर्ष पर। इसे बंद कर दिया जाएगा और इस आशय को एक नई मंशा के रूप में (अब शीर्ष पर) पुरानी गतिविधि को वितरित किया जाएगा।

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

यदि आप FLAG_ACTIVITY_CLEAR_TASK FLAG_ACTIVITY_NEW_TASK के साथ फ्लैग FLAG_ACTIVITY_NEW_TASK का उपयोग करना चाहते हैं, तो यदि आप बैक स्टैक पर सभी एक्टिविटीज़ को खाली करना चाहते हैं:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
// Closing all the Activities, clear the back stack.
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

इरादा यू.आर.आई.

यह उदाहरण दिखाता है, ब्राउज़र से आशय कैसे शुरू करें:

<a href="intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end">Start intent</a>

यह आशय पैकेज com.sample.test साथ ऐप शुरू करेगा या इस पैकेज के साथ गूगल प्ले खोलेगा।

इसके अलावा इस जावास्क्रिप्ट के साथ शुरू किया जा सकता है:

var intent = "intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end";
window.location.replace(intent)

गतिविधि में यह होस्ट और पथ इरादे के डेटा से प्राप्त किया जा सकता है:

@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    Uri data = getIntent().getData(); // returns host.com/path
}

इरादे URI सिंटैक्स:

HOST/URI-path // Optional host
#Intent;
    package=[string];
    action=[string];
    category=[string];
    component=[string];
    scheme=[string];
end;

अन्य घटकों को संदेश प्रसारित करना

आपके एप्लिकेशन के अन्य घटकों (जैसे एक रनिंग बैकग्राउंड सेवा) या संपूर्ण Android सिस्टम पर संदेशों को प्रसारित करने के लिए इंटेंट्स का उपयोग किया जा सकता है।

अपने आवेदन के भीतर एक प्रसारण भेजने के लिए, LocalBroadcastManager वर्ग का उपयोग करें:

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(context);
manager.sendBroadcast(intent);

अपने आवेदन के बाहर के घटकों को प्रसारण भेजने के लिए, Context ऑब्जेक्ट पर sendBroadcast() विधि का उपयोग करें।

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

context.sendBroadcast(intent);

प्रसारण प्राप्त करने के बारे में जानकारी यहाँ मिल सकती है: प्रसारण रिसीवर

CustomTabsIntent क्रोम कस्टम टैब के लिए

String url = "https://www.google.pl/";
CustomTabsIntent intent = new CustomTabsIntent.Builder()
                    .setStartAnimations(getContext(), R.anim.slide_in_right, R.anim.slide_out_left)
                    .setExitAnimations(getContext(), android.R.anim.slide_in_left, android.R.anim.slide_out_right)
                    .setCloseButtonIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_arrow_back_white_24dp))
                    .setToolbarColor(Color.parseColor("#43A047"))
                    .enableUrlBarHiding()
                    .build();
            intent.launchUrl(getActivity(), Uri.parse(url));

compile 'com.android.support:customtabs:24.1.1'

आशय के माध्यम से कई फाइलें साझा करना

स्ट्रिंग सूची को share() पैरामीटर के रूप में पारित किया गया share() विधि में उन सभी फाइलों के पथ शामिल हैं जिन्हें आप साझा करना चाहते हैं।

यह मूल रूप से रास्तों से गुजरता है, उन्हें उरी में जोड़ता है, और गतिविधि शुरू करता है जो इस प्रकार की फ़ाइलों को स्वीकार कर सकती है।

  public static void share(AppCompatActivity context,List<String> paths) {

        if (paths == null || paths.size() == 0) {
            return;
        }
        ArrayList<Uri> uris = new ArrayList<>();
        Intent intent = new Intent();
        intent.setAction(android.content.Intent.ACTION_SEND_MULTIPLE);
        intent.setType("*/*");
        for (String path : paths) {
                File file = new File(path);
                uris.add(Uri.fromFile(file));
        }
        intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
        context.startActivity(intent);
    }

स्टार्टर पैटर्न

यह पैटर्न Activity शुरू करने के लिए एक अधिक सख्त दृष्टिकोण है। इसका उद्देश्य कोड की पठनीयता में सुधार करना है, जबकि एक ही समय में कोड की जटिलता, रखरखाव की लागत और आपके घटकों के युग्मन में कमी आती है।

निम्न उदाहरण स्टार्टर पैटर्न को लागू करता है, जिसे आमतौर पर Activity पर एक स्थिर विधि के रूप में लागू किया जाता है। यह स्थिर विधि सभी आवश्यक मापदंडों को स्वीकार करती है, उस डेटा से एक वैध Intent निर्माण करती है, और फिर Activity शुरू करती है।

एक Intent एक ऐसी वस्तु है जो दो गतिविधियों जैसे अलग-अलग घटकों के बीच रनटाइम बाइंडिंग प्रदान करती है। आशय एक ऐप के "कुछ करने के इरादे" को दर्शाता है। आप विभिन्न प्रकार के कार्यों के लिए इंटेंट्स का उपयोग कर सकते हैं, लेकिन यहां, आपका इरादा दूसरी गतिविधि शुरू करता है।

public class ExampleActivity extends AppCompatActivity {

    private static final String EXTRA_DATA = "EXTRA_DATA";

    public static void start(Context context, String data) {
        Intent intent = new Intent(context, ExampleActivity.class);
        intent.putExtra(EXTRA_DATA, data);
        context.startActivity(intent);
    }       

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = getIntent();
        if(!intent.getExtras().containsKey(EXTRA_DATA)){
            throw new UnsupportedOperationException("Activity should be started using the static start method");
        }
        String data = intent.getStringExtra(EXTRA_DATA);
    }
}

यह पैटर्न आपको इरादे के साथ अतिरिक्त डेटा को पारित करने के लिए मजबूर करने की भी अनुमति देता है।

ExampleActivity तब इस तरह से शुरू की जा सकती है, जहां context एक गतिविधि संदर्भ है:

ExampleActivity.start(context, "Some data!");

एक इरादे का उपयोग करके अनबाउंड सेवा प्रारंभ करें

एक सेवा एक घटक है जो उपयोगकर्ता के साथ सीधे बातचीत के बिना पृष्ठभूमि (यूआई थ्रेड पर) में चलती है। एक अनबाउंड सेवा अभी शुरू की गई है, और किसी भी गतिविधि के जीवन चक्र के लिए बाध्य नहीं है।

एक सेवा शुरू करने के लिए आप नीचे दिए गए उदाहरण में दिखाए जा सकते हैं:

// This Intent will be used to start the service
Intent i= new Intent(context, ServiceName.class);
// potentially add data to the intent extras
i.putExtra("KEY1", "Value to be used by the service");
context.startService(i);

आप एक onStartCommand() ओवरराइड का उपयोग करके इरादे से किसी भी अतिरिक्त का उपयोग कर सकते हैं:

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        if (intent != null) {
            Bundle extras = intent.getExtras();
            String key1 = extras.getString("KEY1", "");
            if (key1.equals("Value to be used by the service")) {
                //do something
            }
        }
        return START_STICKY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

आशय साझा करें

विभिन्न एप्लिकेशन के साथ सरल जानकारी साझा करें।

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(Intent.createChooser(sendIntent, getResources().getText(R.string.send_to)));

विभिन्न एप्लिकेशन के साथ एक छवि साझा करें।

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, getResources().getText(R.string.send_to)));

डायलर शुरू करें

यह उदाहरण दिखाता है कि पहले से ही उपलब्ध टेलीफोन नंबर के साथ एक डिफ़ॉल्ट डायलर (नियमित कॉल करने वाला ऐप) कैसे खोलें:

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:9988776655")); //Replace with valid phone number. Remember to add the tel: prefix, otherwise it will crash.
startActivity(intent);

उपरोक्त कोड चलाने से परिणाम:

निर्दिष्ट अक्षांश, देशांतर के साथ Google मानचित्र खोलें

आप आशय का उपयोग करके अपने ऐप से Google मानचित्र पर अक्षांश, देशांतर पारित कर सकते हैं

String uri = String.format(Locale.ENGLISH, "http://maps.google.com/maps?q=loc:%f,%f", 28.43242324,77.8977673);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri));
startActivity(intent);

इंटेंट इन एक्टिविटी के जरिए अलग-अलग डेटा पास करना

1. पूर्णांक डेटा पास करना:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("intVariableName", intValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
int intValue = mIntent.getIntExtra("intVariableName", 0); // set 0 as the default value if no value for intVariableName found

2. दोहरा डेटा पास करना:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("doubleVariableName", doubleValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
double doubleValue = mIntent.getDoubleExtra("doubleVariableName", 0.00); // set 0.00 as the default value if no value for doubleVariableName found

3. स्ट्रिंग डेटा पास करना:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("stringVariableName", stringValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
String stringValue = mIntent.getExtras().getString("stringVariableName");

या

Intent mIntent = getIntent();
String stringValue = mIntent.getStringExtra("stringVariableName");

4. ArrayList डेटा पास करना:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putStringArrayListExtra("arrayListVariableName", arrayList);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
arrayList = mIntent.getStringArrayListExtra("arrayListVariableName");

5. पासिंग ऑब्जेक्ट डेटा:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("ObjectVariableName", yourObject);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
yourObj = mIntent.getSerializableExtra("ObjectVariableName");

नोट: ध्यान रखें कि आपके कस्टम वर्ग को Serializable इंटरफ़ेस लागू करना होगा।

6. पासिंग हाशप <स्ट्रिंग, स्ट्रिंग> डेटा:

SenderActivity

HashMap <स्ट्रिंग, स्ट्रिंग> hashMap;

Intent mIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
mIntent.putExtra("hashMap", hashMap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();    
HashMap<String, String> hashMap = (HashMap<String, String>)
mIntent.getSerializableExtra("hashMap");

7. बिटमैप डेटा पास करना:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("image",bitmap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();
Bitmap bitmap = mIntent.getParcelableExtra("image");

फ़ाइल चयनकर्ता दिखाना और परिणाम पढ़ना

फ़ाइल चयनकर्ता गतिविधि शुरू करना

public void showFileChooser() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);

    // Update with mime types
    intent.setType("*/*");

    // Update with additional mime types here using a String[]. 
    intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);

    // Only pick openable and local files. Theoretically we could pull files from google drive
    // or other applications that have networked files, but that's unnecessary for this example.
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);

    // REQUEST_CODE = <some-integer>
    startActivityForResult(intent, REQUEST_CODE);
}

रिजल्ट पढ़ना

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the user doesn't pick a file just return
    if (requestCode != REQUEST_CODE || resultCode != RESULT_OK) {
        return;
    }

    // Import the file
    importFile(data.getData());
}

public void importFile(Uri uri) {
    String fileName = getFileName(uri);

    // The temp file could be whatever you want
    File fileCopy = copyToTempFile(uri, File tempFile)

    // Done!
}

/**
 * Obtains the file name for a URI using content resolvers. Taken from the following link
 * https://developer.android.com/training/secure-file-sharing/retrieve-info.html#RetrieveFileInfo
 *
 * @param uri a uri to query
 * @return the file name with no path
 * @throws IllegalArgumentException if the query is null, empty, or the column doesn't exist
 */
private String getFileName(Uri uri) throws IllegalArgumentException {
    // Obtain a cursor with information regarding this uri
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);

    if (cursor.getCount() <= 0) {
        cursor.close();
        throw new IllegalArgumentException("Can't obtain file name, cursor is empty");
    }

    cursor.moveToFirst();

    String fileName = cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME));

    cursor.close();

    return fileName;
}

/**
 * Copies a uri reference to a temporary file
 *
 * @param uri      the uri used as the input stream
 * @param tempFile the file used as an output stream
 * @return the input tempFile for convenience
 * @throws IOException if an error occurs
 */
private File copyToTempFile(Uri uri, File tempFile) throws IOException {
    // Obtain an input stream from the uri
    InputStream inputStream = getContentResolver().openInputStream(uri);

    if (inputStream == null) {
        throw new IOException("Unable to obtain input stream from URI");
    }

    // Copy the stream to the temp file
    FileUtils.copyInputStreamToFile(inputStream, tempFile);

    return tempFile;
}

गतिविधियों के बीच कस्टम वस्तु पासिंग

Bundle क्लास का उपयोग करके अपनी कस्टम ऑब्जेक्ट को अन्य गतिविधियों के लिए भी पास करना संभव है।

इसके दो तरीके हैं:

• जावा और Android के लिए Serializable इंटरफ़ेस
• Parcelable इंटरफ़ेस- मेमोरी कुशल, केवल Android के लिए (अनुशंसित)

Parcelable

पार्सल करने योग्य प्रसंस्करण क्रमिक की तुलना में बहुत तेज है। इसका एक कारण यह है कि हम इसे अनुमान लगाने के लिए प्रतिबिंब का उपयोग करने के बजाय क्रमांकन प्रक्रिया के बारे में स्पष्ट हो रहे हैं। यह इस कारण से भी है कि इस उद्देश्य के लिए कोड को भारी रूप से अनुकूलित किया गया है।

public class MyObjects implements Parcelable {
    
    private int age;
    private String name;
    
    private ArrayList<String> address;
    
    public MyObjects(String name, int age, ArrayList<String> address) {
        this.name = name;
        this.age = age;
        this.address = address;
    
    }
    
    public MyObjects(Parcel source) {
        age = source.readInt();
        name = source.readString();
        address = source.createStringArrayList();
    }
    
    @Override
    public int describeContents() {
        return 0;
    }
    
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeStringList(address);
    }
    
    public int getAge() {
        return age;
    }
    
    public String getName() {
        return name;
    }
    
    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }
    
    public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
        @Override
        public MyObjects[] newArray(int size) {
            return new MyObjects[size];
        }
    
        @Override
        public MyObjects createFromParcel(Parcel source) {
            return new MyObjects(source);
        }
    };
}

गतिविधि कोड भेजना

MyObject mObject = new MyObject("name","age","Address array here");

//Passing MyOject 
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObject);
startActivity(mIntent);

गंतव्य गतिविधि में वस्तु प्राप्त करना।

//Getting MyObjects 
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects) mIntent.getParcelable("UniqueKey");

आप नीचे की तरह Parceble ऑब्जेक्ट की Arraylist पास कर सकते हैं

//Array of MyObjects
ArrayList<MyObject> mUsers;

//Passing MyObject List
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putParcelableArrayListExtra("UniqueKey", mUsers);
startActivity(mIntent);

//Getting MyObject List
Intent mIntent = getIntent();
ArrayList<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");

नोट: वहाँ एंड्रॉयड स्टूडियो जैसे प्लगइन्स हैं यह एक Parcelable कोड उत्पन्न करने के लिए उपलब्ध

serializable

गतिविधि कोड भेजना

Product product = new Product();
Bundle bundle = new Bundle();
bundle.putSerializable("product", product);
Intent cartIntent = new Intent(mContext, ShowCartActivity.class);
cartIntent.putExtras(bundle);
mContext.startActivity(cartIntent);

गंतव्य गतिविधि में वस्तु प्राप्त करना।

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle bundle = this.getIntent().getExtras();
    Product product = null;
    if (bundle != null) {
        product = (Product) bundle.getSerializable("product");
    }

Arraylist Serializable वस्तु की: एक वस्तु के रूप में ही गुजर

कस्टम ऑब्जेक्ट को Serializable इंटरफ़ेस को लागू करना चाहिए।

एक्टिविटी से लेकर फ्रैगमेंट तक एक परिणाम

एक अन्य गतिविधि से परिणाम प्राप्त करने की तरह आपको Fragment की विधि startActivityForResult(Intent intent, int requestCode) पर कॉल करने की आवश्यकता है। ध्यान दें कि आपको getActivity().startActivityForResult() नहीं शुरू करना चाहिए getActivity().startActivityForResult() क्योंकि यह परिणाम वापस Fragment की मूल Activity ।

परिणाम प्राप्त करना Fragment की विधि onActivityResult() का उपयोग करके किया जा सकता है। आपको यह सुनिश्चित करने की आवश्यकता है कि फ्रैगमेंट की मूल गतिविधि भी onActivityResult() ओवरराइड onActivityResult() और इसे super कार्यान्वयन कहती है।

निम्नलिखित उदाहरण में ActivityOne में FragmentOne शामिल है, जो ActivityTwo शुरू करेगा और इससे परिणाम की उम्मीद करेगा।

ActivityOne

public class ActivityOne extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }

    // You must override this method as the second Activity will always send its results to this Activity and then to the Fragment
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
    }
}

activity_one.xml

<fragment android:name="com.example.FragmentOne"
    android:id="@+id/fragment_one"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

FragmentOne

public class FragmentOne extends Fragment {
    public static final int REQUEST_CODE = 11;
    public static final int RESULT_CODE = 12;
    public static final String EXTRA_KEY_TEST = "testKey";

    // Initializing and starting the second Activity
    private void startSecondActivity() {
        Intent intent = new Intent(getActivity(), ActivityTwo.class);
        startActivityForResult(REQUEST_CODE, intent);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CODE && resultCode == RESULT_CODE) {
            String testResult = data.getStringExtra(EXTRA_KEY_TEST);
            // TODO: Do something with your extra data
        }
    }
}

ActivityTwo

public class ActivityTwo extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
    }

    private void closeActivity() {
        Intent intent = new Intent();
        intent.putExtra(FragmentOne.EXTRA_KEY_TEST, "Testing passing data back to ActivityOne");
        setResult(FragmentOne.RESULT_CODE, intent); // You can also send result without any data using setResult(int resultCode)
        finish();
    }
}