परिचय

इस लेख में चर्चा की जाएगी कि एक ऐसे व्यक्ति को कैसे बताया जाए जो पहले एंड्रॉइड के लिए प्रोग्रामिंग से परिचित नहीं था, इसके मुख्य घटकों के बारे में। दिलचस्पी दिखाने और यह दिखाने के लिए कि सब कुछ उतना मुश्किल नहीं है जितना कि कई लोग सोचते हैं। इसी समय, इसे 15 मिनट में करें और कुछ मूल सिद्धांत की व्याख्या के बिना, जिसे हर कोई अपने लिए पढ़ सकता है और स्पष्ट प्रश्नों के साथ वापस आ सकता है।

जब मैंने पहली बार ऐसा करने की कोशिश की, तो मैं अपने आप को बहुत आश्चर्यचकित हुआ। मेरी "सरल और समझने योग्य" व्याख्या उबाऊ में बदल गई, जिसके ढांचे के भीतर एक विशालता को समझने और संक्षेप में बताने के लिए एक हताश प्रयास स्पष्ट रूप से पता लगाया गया था। कहने की जरूरत नहीं है, इस तरह की कहानी में रुचि होने की संभावना नहीं है, बल्कि आपके इंटरकोलेक्टर को डराता है, जबकि अपनी खुद की कुछ करने की इच्छा कम हो जाती है, भले ही आपके पास पहले से आपकी योजनाओं में एक छोटा कैलकुलेटर था।

यह कोई रहस्य नहीं है कि इस विषय पर बड़ी संख्या में लेख इंटरनेट पर पोस्ट किए गए हैं, लेकिन मेरे मामले में कथा थोड़ा अलग होगी: परिभाषाओं और अन्य विवरणों के बिना केवल दृश्य अभ्यास होगा। यही है, हम देखते हैं - हम देखते हैं - हम इस पर टिप्पणी करते हैं कि क्या हो रहा है। ऐसा लगता है, मेरी राय में, सब कुछ काफी सरल और स्पष्ट है, कोड के टुकड़े भी छोटे और बहुत सरल हैं, अपने स्वयं के प्रोजेक्ट में त्वरित उपयोग के लिए तैयार हैं। मुझे ऐसा लगता है कि यह दृष्टिकोण क्लासिक एंड्रॉइड टूल का एक व्यापक रूप से विस्तृत अवलोकन देता है, और पहला एप्लिकेशन लिखते समय, "मुझे क्या उपयोग करना चाहिए" सवालों के बजाय, "अधिक विशिष्ट प्रश्न" कैसे मुझे घटक एक्स का उपयोग करना चाहिए "। और पहले से ही एक व्यक्ति इसके बारे में सभी विवरणों का पता लगाने में सक्षम होगा - अगर वह चाहे।

तो चलिए!

घटकों को सीखना

एप्लिकेशन इंस्टॉल करें, इसे लॉन्च करें, और ... अभी के लिए, यह पर्याप्त है कि मेनएक्टिविटी हमारे सामने खुल गई है। सवाल "आखिर क्यों है" इसका जवाब बाद में दिया जाएगा।

सबसे पहले, आइए देखें कि यह कहां से आता है - main_activity.xml से, जहां सभी इंटरफ़ेस तत्व घोषित किए जाते हैं। वे LinearLayout में तैनात हैं, इसलिए यहां सवाल उठने की संभावना नहीं है।

<LinearLayout android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <TextView android:id="@+id/textView" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Android Demo Application" /> <TextView android:id="@+id/textView3" android:layout_width="match_parent" android:layout_height="wrap_content" android:text=" 1" /> <Button android:id="@+id/buttonShowToast" android:layout_width="match_parent" android:layout_height="wrap_content" android:text=" Toast" /> ... </LinearLayout> 

सरल घटक

टोस्ट

अब आइए MainActivity.java और इसके इंटरफ़ेस के पहले बटन पर जाएं - "शो टोस्ट" (पॉप-अप नोटिफिकेशन)।
Main_activity.xml में बटन के पहचानकर्ता का पता लगाएं और MainActivity.java में इसके OnClickListener पर जाएं।

 Button btn = findViewById(R.id.buttonShowToast); btn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Toast.makeText(getApplicationContext(), "This is a Toast", Toast.LENGTH_LONG).show(); } }); 

यह पता चला है कि एक पॉप-अप अधिसूचना प्रदर्शित करने के लिए, कोड की एक पंक्ति पर्याप्त है! महान, है ना?

एक अन्य गतिविधि के साथ सहभागिता

अब आवेदन के मुख्य पृष्ठ के बाहर कहीं जाने की कोशिश करते हैं। उदाहरण के लिए, ऐसे अन्य पृष्ठ पर! "अन्य गतिविधि के साथ सहभागिता" पर जाएं - और हम अन्य नियंत्रणों के साथ किसी अन्य गतिविधि में शामिल हो जाते हैं। एक अनुप्रयोग में विभिन्न गतिविधियाँ आपस में डेटा ट्रांसफर कैसे करती हैं? यहां दो अलग-अलग तंत्रों के बारे में बात करने का समय है: मूल्यों का एक निरंतर भंडारण - साझा_प्रश्न, साथ ही startActivityForResult / onActivityResult (मैं शुरुआत में इसे सम्मिलित नहीं करना चाहता था, लेकिन फिर भी संक्षेप में, यदि आप startActivityForResult का उपयोग करके एक खुली गतिविधि से एक नई गतिविधि शुरू करते हैं, तो दूसरी गतिविधि पूरी होने के बाद। पहली गतिविधि में onActivityResult कहा जाएगा। यदि यह अभी तक स्पष्ट नहीं है तो चिंतित न हों)।
और निश्चित रूप से, व्यवहार में प्रदर्शित करता है!

साझा_प्रकार में प्रवेश:

 String valueToSave = "test"; SharedPreferences.Editor editor = getSharedPreferences("demoapp", MODE_PRIVATE).edit(); editor.putString("myValue", valueToSave); editor.apply(); 

साझा_प्रकार से पढ़ना:

 SharedPreferences prefs = getSharedPreferences("demoapp", MODE_PRIVATE); String storedValue = prefs.getString("myValue", "NOT_FOUND"); 

OnActivityResult के साथ एक उदाहरण - एप्लिकेशन स्रोत में देखें।

सेटिंग्स को सहेजना और पुनर्स्थापित करना

चूंकि हमने साझा किए गए_प्रश्न का उल्लेख किया है, चलो उनके साथ समाप्त होते हैं। हम "सेटिंग्स को सहेजना और पुनर्स्थापित करना" पर जाते हैं, जहां हमें विभिन्न प्रकार के फ़ील्ड्स के साथ एक विशिष्ट खाते के एक विशिष्ट कार्ड के साथ प्रस्तुत किया जाता है (ध्यान दें कि उनका प्रकार केवल एक चर द्वारा सेट किया गया है - एक स्विच)। हम इन फ़ील्ड्स के कंटेंट को शेयर्ड_पर्फ्स में सेव करेंगे, और फिर उन्हें रीस्टोर करेंगे। अब तक, एक अलग बटन, नहीं onResume - हम अभी तक उन तक नहीं पहुंचे हैं!
सहेजें:

 SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit(); EditText et = findViewById(R.id.editTextName); String name = et.getText().toString(); editor.putString("name", name); editor.apply(); 

हम पुनर्स्थापित करते हैं:

 SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE); EditText et = findViewById(R.id.editTextName); et.setText(prefs.getString("name", "")); ... 

सरल मेनू

अगला भाग एक साधारण मेनू है। हम इससे सीखते हैं कि इसमें कुछ भी जटिल नहीं है - बस onCreateOptionsMenu सेट करें और इसे my_menu.xml से संरचना के साथ भरें।

 @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.my_menu, menu); return true; } 

पॉपअप मेनू

इसके तुरंत बाद - एक पॉप-अप मेनू बटन। यह सेटिंग्स मेमोरी की उपस्थिति और सबमेनस की उपस्थिति के साथ भी पहले से ही अधिक दिलचस्प है।
पॉप-अप मेनू के लिए कोड को एप्लिकेशन के स्रोत कोड में देखा जा सकता है।

ऑडियो प्लेयर

ऑडियो प्लेयर के उदाहरण का उपयोग करते हुए, इस तथ्य के अलावा कि संगीत बजाने में कुछ भी जटिल नहीं है, आप मीडिया प्लेयर की वर्तमान स्थिति के लिए, इस मामले में, कुछ को चाहने वाले के बंधन को प्रदर्शित कर सकते हैं। वॉल्यूम नियंत्रण में - कुछ भी अलौकिक नहीं है। बोनस एक त्रुटि दिखाता है। मीडिया प्लेयर के साथ गतिविधि खोलें, प्लेबैक शुरू करें और "बैक" बटन दबाएं। संगीत खेलना जारी है, और इसे अब रोका नहीं जा सकता ... समस्या! इसे कैसे हल करें - हम थोड़ी देर बाद पता लगाएंगे।
ऑडियो प्लेयर का कोड एप्लिकेशन के स्रोत कोड में पाया जा सकता है।

वेब ब्राउज़र

खैर, पहले भाग के निष्कर्ष में, हम दिखाते हैं कि वेब ब्राउज़र में कुछ भी दिव्य नहीं है।

 WebView view = findViewById(R.id.webView); view.setWebViewClient(new WebViewClient()); view.getSettings().setJavaScriptEnabled(true); view.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE); view.loadUrl("https://google.com"); 

अगला भाग पहले से कठिन है।

सेवाएँ और सूचनाएँ

BroadcastReceiver

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

 public BroadcastReceiver MyReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { Toast.makeText(getApplicationContext(), "Broadcast receiver: received!", Toast.LENGTH_LONG).show(); } }; 

यहां आप बिना इंटेंट के नहीं कर सकते, लेकिन सबसे आदिम स्तर पर: अभी के लिए, यह तथ्य कि वे हमारे लिए पर्याप्त हैं, एक निश्चित सामान्य बस में भेजे जाते हैं, और एक पूर्व निर्धारित कार्रवाई के अनुसार, ब्रॉडकास्टर हमें जहां भी हैं, हमें सुनेंगे।

 IntentFilter filter = new IntentFilter(); filter.addAction("MyCustomActionName"); registerReceiver(MyReceiver, filter); sendBroadcast(new Intent("MyCustomActionName")); 

फिलहाल, हमारे पास एक मूल विचार है कि प्राप्तकर्ता क्या है, लेकिन इसकी आवश्यकता क्यों है यह स्पष्ट नहीं है: यह सामान्य है, और अब यह आसान हो जाएगा।

सरल सेवा

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

 public BroadcastReceiver MyServiceReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { Toast.makeText(getApplicationContext(), "Toast from Service: I hear you!", Toast.LENGTH_LONG).show(); } }; 

टेक्स्ट व्यू में सेवा के परिणामों को प्रदर्शित करने के लिए रिसीवर इन एक्टिविटी की आवश्यकता होती है।

 public BroadcastReceiver MyPrintReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { Toast.makeText(getApplicationContext(), "pong", Toast.LENGTH_SHORT).show(); TextView tv = findViewById(R.id.textViewSimpleServiceStatus); String msg = intent.getStringExtra("msg"); tv.setText(msg); } }; 

और, पूर्ण समझ के लिए, सेवा से गतिविधि पर संदेश भेजते समय, हम टोस्ट ("पिंग") प्रदर्शित करेंगे। और जब हम गतिविधि में संदेश प्राप्त करते हैं और वास्तव में TextView में मूल्य आकर्षित करते हैं, तो हम टोस्ट ("पोंग") प्रदर्शित करेंगे।
बता दें कि सेवा का मुख्य कार्य इस तरह के "पिंग्स" को गतिविधि में भेजना है, और गतिविधि का कार्य बस उन्हें इसके इंटरफ़ेस में प्रदर्शित करना है।

 Handler handler = new Handler(); runnable = new Runnable() { public void run() { if (running) { printMsg("Service is still running " + running); handler.postDelayed(runnable, 5000); //   } else { printMsg("Service exited"); } } }; handler.postDelayed(runnable, 5000); 

हैंडलर ऑपरेशन का एक उदाहरण बाद में विस्तार से माना जाएगा, फिलहाल यह हर 5 सेकंड में पिंग भेजने का एक साधन है।

और अब, सेवा शुरू करने के बाद, हम टोस्ट ("सेवा निर्मित!") देखते हैं और पिंग-पोंग सूचनाएं भेजते हैं। और TextView में सेवा से संदेश आने लगे।

महान, पृष्ठभूमि निष्पादन हमने देखा। अब एप्लिकेशन को बंद करें! एंड्रॉइड के नवीनतम संस्करणों पर, हम निम्नलिखित देखेंगे: सेवा फिर से शुरू हो गई है (टोस्ट ("सेवा निर्मित!") दिखाई देगी) और "पिंग" भेजें। इसी समय, कोई "चिमटा" नहीं है - आखिरकार, कोई और गतिविधि नहीं है जो उन्हें संसाधित करती है! कुछ सेकंड के बाद, मेरे स्मार्टफोन पर पिंग भी बंद हो गए। सेवा नष्ट हो रही है। ऊर्जा सेटिंग्स खोलें, हमारे आवेदन के लिए अनुकूलन बंद करें और फिर से प्रक्रिया करें। अब सेवा नष्ट नहीं हुई है, और कार्यक्रम बंद होने के बाद भी, हम महत्वपूर्ण रूप से आने वाले "पिंग" को देखते हैं। लेकिन, ज़ाहिर है, यहां कोई गारंटी नहीं है, और ऐसी सेवा बहुत लंबे समय तक नहीं रहेगी। डेवलपर के दृष्टिकोण से, यह भयानक हो सकता है, लेकिन आइए इसे एक साधारण उपयोगकर्ता की आंखों के माध्यम से देखें: क्या हम चाहते हैं कि कोई भी एप्लिकेशन इतनी स्वतंत्र रूप से पृष्ठभूमि में काम करे और एक बैटरी खाए? शायद ही। फिर पृष्ठभूमि में पूरी तरह से काम करने के लिए कैसे?

ऐसा करने के लिए, आपको केवल इस बारे में उपयोगकर्ता को सूचित करना होगा। यह एंड्रॉइड की एक अनिवार्य आवश्यकता है, जो एक अधिसूचना चैनल की उपस्थिति में, आपको न केवल सामान्य रूप से लॉन्च करने की अनुमति देता है, बल्कि फोरग्राउंड सेवा, जो पूरी तरह से नीले रंग से मारे जाने के जोखिम के बिना पृष्ठभूमि में काम करेगी।
हमारी सेवा में शामिल हों:

 String CHANNEL_ID = "my_channel_01"; NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Channel human readable title", NotificationManager.IMPORTANCE_DEFAULT); ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).createNotificationChannel(channel); Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID) .setContentTitle("") .setContentText("").build(); startForeground(1, notification); 

और हम इसे कमांड के साथ चलाएंगे:

 startForegroundService(new Intent(getApplicationContext(), TestServiceForeground.class)); 

हम अपने डेमो एप्लिकेशन पर लौटेंगे, ऊर्जा-बचत सेटिंग्स को उनकी मूल स्थिति में लौटाएंगे। और अब हम अग्रभूमि सेवा लॉन्च करेंगे। जब सेवा चल रही हो, तब एप्लिकेशन को बंद करके, हम ध्यान दें कि सेवा अब पुनरारंभ नहीं हो रही है और नष्ट नहीं हो रही है, लेकिन बस पृष्ठभूमि में काम करना जारी है, हर 5 सेकंड में अपने "पिंग्स" भेज रहा है। इसी समय, अधिसूचना में एक सूचना आइकन लटका रहेगा।

उपयोगकर्ता इन सूचनाओं को यदि वह चाहे तो छिपा सकता है, लेकिन अधिसूचना चैनल बनाते समय आप उन्हें प्रोग्रामेटिक रूप से छिपा नहीं सकते।

फ्लोटिंग बटन (ओवरले)

यह जानना कि एक सेवा क्या है, आप इसके सरलतम और सबसे स्पष्ट उपयोग पर आगे बढ़ सकते हैं - फ्लोटिंग बटन के साथ काम करना। वर्तमान एंड्रॉइड पर, आप ओवरले को केवल उसी तरह अधिकार प्रदान करने की घोषणा नहीं कर सकते हैं - आपको उपयोगकर्ता से "सभी विंडो के ऊपर" अनुमति के लिए स्पष्ट रूप से पूछने की आवश्यकता है। फिर हम ड्रा ओवरले पर क्लिक करते हैं और हमें एक फ्लोटिंग आइकन दिखाई देता है, जिसके पीछे वास्तव में एक सेवा है जो उस पर क्लिक करने के लिए सुनती है।

सूचनाएं भेज रहा है

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

 private void createNotificationChannel() { try { CharSequence channelName = CHANNEL_ID; String channelDesc = "channelDesc"; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { int importance = NotificationManager.IMPORTANCE_LOW; NotificationChannel channel = new NotificationChannel(CHANNEL_ID, channelName, importance); channel.setDescription(channelDesc); NotificationManager notificationManager = getSystemService(NotificationManager.class); assert notificationManager != null; NotificationChannel currChannel = notificationManager.getNotificationChannel(CHANNEL_ID); if (currChannel == null) { notificationManager.createNotificationChannel(channel); Toast.makeText(getApplicationContext(), "channel created", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(getApplicationContext(), "channel exists", Toast.LENGTH_SHORT).show(); } } } catch (Exception e) { } } 

ठीक है, तो आप प्रतिबंधों के बिना इसे सूचनाएं भेज सकते हैं।

 public void setNotify() { try { Intent snoozeIntent = new Intent("ActionFromNotify"); PendingIntent snoozePendingIntent = PendingIntent.getBroadcast(this, 0, snoozeIntent, 0); String title = "Start"; Intent intent = new Intent(this, MainActivity.class); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); NotificationCompat.Action action = new NotificationCompat.Action.Builder(R.drawable.ic_launcher_background, title, snoozePendingIntent).build(); NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this, CHANNEL_ID) .setSmallIcon(R.drawable.ic_launcher_background) .setContentTitle("MyNotification") .setContentText("Text here") .setPriority(NotificationCompat.PRIORITY_LOW) .setContentIntent(null) .setOngoing(true) //   .setSound(null) .addAction(action); NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this); int notificationId = (int) (System.currentTimeMillis() / 4); notificationManager.notify(notificationId, mBuilder.build()); } catch (Exception e) { Log.e("error", e.toString()); } } 

सूचनाएं भेजने के साथ सेवा

गतिविधि से सीधे सूचनाएं भेजना, आप देखते हैं, बहुत प्रभावशाली नहीं है। हम अभी भी कुछ और करने के लिए उपयोग किया जाता है। लेकिन हम अब तक की पृष्ठभूमि के निष्पादन के बारे में क्या जानते हैं? बस सेवाएं हैं। तो चलो जल्दी मत करो और एक साधारण सेवा बनाओ (फॉरएग्राउंड भी नहीं - सरलता के लिए) जो हर 5 सेकंड में एक नई अधिसूचना भेजता है। सहमत हूँ, यह पहले से ही एक बटन द्वारा सूचनाएं भेजने की तुलना में पहले से ही बेहतर और प्रभावशाली है।

प्रतीत होता है कि जटिल सेवाओं के बाद एक संक्षिप्त ठहराव के रूप में (यदि आप उनसे पहले कभी नहीं मिले हैं), हम चार नियंत्रणों पर विचार करेंगे जो समझने में आसान हैं। और फिर हम जटिल सामग्री की ओर मुड़ते हैं - प्रवाह के लिए।

अतिरिक्त घटक

डेटा तालिका

डेटा टेबल के साथ अपना पॉज़ शुरू करते हैं। स्रोत कोड का अध्ययन पाठक तक छोड़ दिया जाता है।

टैब्ड विंडो

अगला पड़ाव एक वर्जित खिड़की है। एक साधारण टैब व्यू की सहायता से, आप एक स्क्रीन पर कई गतिविधियाँ रख सकते हैं।

 public class TabsActivity extends TabActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.tabs_activity); //  TabHost TabHost tabHost = getTabHost(); TabHost.TabSpec tabSpec; tabSpec = tabHost.newTabSpec("tag1"); tabSpec.setIndicator(""); tabSpec.setContent(new Intent(this, SaveRestorePrefsActivity.class)); tabHost.addTab(tabSpec); tabSpec = tabHost.newTabSpec("tag2"); tabSpec.setIndicator(""); tabSpec.setContent(new Intent(this, FloatingMenuActivity.class)); tabHost.addTab(tabSpec); ... } } 

प्रदर्शित करने वाली संरचना की वस्तुएँ: टुकड़े और मेज

संरचना वस्तुओं का उत्पादन टुकड़ों और एक तालिका के साथ किया जा सकता है।
इस तरह से टुकड़ों से भरना दिखता है

और इसलिए तालिका

गतिविधि जीवन चक्र

धीरे-धीरे अपने ठहराव को समाप्त करते हुए, हम गतिविधि के जीवन चक्र पर आगे बढ़ते हैं। यहां यह पता लगाने का समय है कि ऑनक्रिएट के अलावा और भी कई तरीके हैं। कोड और पॉप-अप नोटिफिकेशन का एक छोटा सा टुकड़ा उन्हें किसी भी स्पष्टीकरण से बेहतर समझने में मदद करेगा।

 @Override protected void onResume() { super.onResume(); Toast.makeText(getApplicationContext(), "onResume -    ", Toast.LENGTH_SHORT).show(); } @Override protected void onDestroy() { super.onDestroy(); Toast.makeText(getApplicationContext(), "onDestroy -  ", Toast.LENGTH_SHORT).show(); } @Override protected void onPause() { super.onPause(); Toast.makeText(getApplicationContext(), "onPause -      ", Toast.LENGTH_SHORT).show(); } 

वही OnTouchListener'ov, और onTextChanged पर लागू होता है।

 CheckBox cb = findViewById(R.id.checkBoxChangeExample); cb.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { printMsg("CheckBox - OnCheckedChangeListener: new value is checked = " + isChecked); } }); SeekBar seekBar = (SeekBar) findViewById(R.id.seekBarChangeExample); seekBar.setMax(100); seekBar.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { Integer progress = ((SeekBar)v).getProgress(); printMsg("SeekBar - OnTouchListener: new value is = " + progress.toString()); return false; } }); 

विलंबित, समानांतर और नियमित निष्पादन

हम कहानी के सबसे कठिन हिस्से में बदल जाते हैं - आस्थगित और समानांतर निष्पादन।

विलंबित निष्पादन: हैंडलर

चलो हैंडलर के साथ गोता शुरू करते हैं। सभी विवरणों में एक हैंडलर क्या है - एक व्यक्ति बाद में इसे खुद पढ़ेगा, हम उसे इस आनंद से वंचित नहीं करेंगे। लेकिन, चूंकि हम इस पर विचार कर रहे हैं, इसलिए मुख्य बात जानना जरूरी है - कि यह आपको एक लंबित कार्य करने की अनुमति देता है, और यह समानांतर में नहीं होता है।
इसे दिखाओ। आइए एक हैंडलर बनाएं, इसमें "Toast को 5 सेकंड में आउटपुट" करने के लिए कार्य जोड़ें। हम देखते हैं कि टोस्ट वापस ले लिया गया था और कोई भी नींद (पूरे कार्यक्रम के निष्पादन में ठहराव) की आवश्यकता नहीं थी।

 Handler handler = new Handler(); Runnable r = new Runnable() { public void run() { Toast.makeText(getApplicationContext(), "Delayed task executed", Toast.LENGTH_SHORT).show(); } }; handler.postDelayed(r, 5000); 

अब हैंडलर में एक चक्रीय कार्य जोड़ें:

 Runnable r = new Runnable() { public void run() { Toast.makeText(getApplicationContext(), "Delayed task executed", Toast.LENGTH_SHORT).show(); handler.postDelayed(this, 5000); //   } }; handler.postDelayed(r, 5000); 

यह सुनिश्चित करने के बाद कि यह प्रत्येक 5 सेकंड चलता है, हैंडलर को साफ़ करें

 handler.removeCallbacksAndMessages(null); 

यह प्रदर्शित करना बाकी है कि हैंडलर के कार्यों का निष्पादन समानांतर में नहीं होता है। इसे दिखाने का सबसे आसान तरीका यह है कि इसे कुछ भारी और एक ही समय में सरल तरीके से लोड किया जाए। जैसे ... नींद के बिना (सच)! दस सेकंड, ताकि पूरी तरह से आवेदन को मारने के लिए नहीं।

 Runnable r = new Runnable() { public void run() { long initTime = System.currentTimeMillis(); boolean timeElapsed = false; while(!timeElapsed){ if(System.currentTimeMillis() - initTime > 10000 ){ timeElapsed = true; //   ,   ! (  ,    ).         sleep } } } }; Toast.makeText(getApplicationContext(), "Hard Delayed task started", Toast.LENGTH_SHORT).show(); handler.postDelayed(r, 100); 

ऐसे कार्य को लॉन्च करते हुए, हम देखते हैं कि एप्लिकेशन इन 10 सेकंड के लिए हमारे क्लिकों का जवाब नहीं देता है - यह पूरी तरह से और पूरी तरह से हमारे जटिल चक्र को संसाधित करने में व्यस्त है। इस उदाहरण के बाद दूसरा निष्कर्ष यह है कि आप इंटरफ़ेस के साथ एक ही थ्रेड में संसाधन-गहन कार्य नहीं कर सकते। यूआई धागा हमेशा मुक्त होना चाहिए, और इसके कार्यों को जितनी जल्दी हो सके बाहर काम करना चाहिए। UI स्ट्रीम में कुछ संचालन स्पष्ट रूप से निषिद्ध हैं: उदाहरण के लिए, एंड्रॉइड यूआई स्ट्रीम में इंटरनेट तक पहुंचने की कोशिश करने पर एप्लिकेशन को क्रैश कर देगा।

समवर्ती निष्पादन: स्ट्रीम

तार्किक सवाल अब यह है कि नए धागे कैसे बनाएं और समानांतर में काम करें?
हम धारा के निर्माण और इसके समानांतर संचालन के तथ्य दोनों को दिखाते हैं। चलो एक स्ट्रीम बनाते हैं और इसे उसी कार्य के साथ लोड करते हैं, जिसके कारण, हेबलर के मामले में, हमें 10 सेकंड के लिए निष्क्रिय इंटरफ़ेस के साथ छोड़ दिया गया था।

 Thread thread = new Thread() { @Override public void run() { try { sendMsgUsingBroadcast("Thread started"); long initTime = System.currentTimeMillis(); boolean timeElapsed = false; while(!timeElapsed){ if(System.currentTimeMillis() - initTime > 10000 ){ timeElapsed = true; } } sendMsgUsingBroadcast("Thread stopped"); } catch (Exception e) { sendMsgUsingBroadcast("Thread error " + e.toString()); } } }; thread.start(); 

बनाया गया, लोड किया गया - और इंटरफ़ेस काम करता है! धागे का निष्पादन समानांतर में होता है।
अगला सवाल यह है कि प्रवाह को कैसे नियंत्रित किया जाए। यह समझना महत्वपूर्ण है कि एक धागा केवल तभी पूरा होगा जब इसके स्रोत कोड को निष्पादित किया जाएगा। आप केवल स्ट्रीम नहीं ले सकते और मार सकते हैं। यह साझा करने के बारे में सोचने का समय है। शेयर्स और सिंक्रोनाइज़ेशन के लिए वैरिएबल को लागू करें: स्ट्रीम की शुरुआत के साथ रनिंग = ट्रू चर को सेट करें। इसके प्रत्येक पुनरावृत्तियों में, थ्रेड यह जांचता है कि क्या चल रहा है == सच निष्पादित हो रहा है, और यदि नहीं, तो इसका निष्पादन पूरा होता है।

 Thread thread = new Thread() { @Override public void run() { try { sendMsgUsingBroadcast("Thread started"); SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE); while (true) { if (!prefs.getBoolean("running", false)) { break; } else { try { Thread.sleep(100); } catch (Exception e) {} } } sendMsgUsingBroadcast("Thread stopped"); } catch (Exception e) { sendMsgUsingBroadcast("Thread error " + e.toString()); } } }; thread.start(); 

इसलिए, हम कुछ कदम आगे बढ़े हैं और अब हम न केवल सेवा के बारे में जानते हैं, बल्कि हैंडलर और स्ट्रीम के बारे में भी जानते हैं। ऐसा लगता है कि ये उपकरण एक एप्लिकेशन लिखना शुरू करने के लिए पर्याप्त हैं जिसमें नियमित उपयोगकर्ता अधिसूचना के कार्यों में से एक है। लेकिन उनके पास एक विशेषता है: उनमें से सभी इस तथ्य से एकजुट हैं कि हम एक सेकंड के लिए नियंत्रण नहीं खोते हैं, और हमेशा किसी न किसी तरह के अंतहीन चक्र में रहने के लिए मजबूर होते हैं जो ज्यादातर समय सोता है और कभी-कभी यह जांचने के लिए उठता है कि क्या कुछ शर्तों को समझने के लिए - कटौती करने के लिए उपयोगकर्ता नोटिस या लंबे समय के लिए फिर से सो जाते हैं। यह एक सिरदर्द जोड़ता है: क्या होगा यदि हमारी सेवा या एप्लिकेशन बैटरी ऑप्टिमाइज़र को मारता है, और हम एक छोटे से आवश्यक नहीं सीटी की खातिर इतने सारे स्मार्टफोन संसाधनों को क्यों खाते हैं? , , , - , ?

: AlarmManager

AlarmManager.

, — sendBroadcast Action, BroadcastReceiver!

BroadcastReceiver, , , :

 public class MyAlarmServiceReceiver extends BroadcastReceiver { private String CHANNEL_ID = "MyNotificationsChannel"; @Override public void onReceive(Context context, Intent intent) { Toast.makeText(context, "MyAlarmServiceReceiver onReceive", Toast.LENGTH_SHORT).show(); setNotify("Notify from AlarmManager", context); } } 

AlarmManager Receiver 15 :

 AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE); Intent intent = new Intent(AlarmActivity.this, MyAlarmServiceReceiver.class); PendingIntent pendingIntent = PendingIntent.getBroadcast(getApplicationContext(), 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); Calendar calendar = Calendar.getInstance(); calendar.setTimeInMillis(System.currentTimeMillis()); calendar.set(Calendar.HOUR_OF_DAY, 1); calendar.set(Calendar.MINUTE, 10); //alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, 1 * 60 * 1000, pendingIntent); // not repeating - just one run, if needed alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), AlarmManager.INTERVAL_FIFTEEN_MINUTES, pendingIntent); 

: 15 .

( ) .

Logcat Reader , .
( ) , .

 String LOG_TAG = "MYDEMOAPP"; Log.i(LOG_TAG, "Test info log"); Log.d(LOG_TAG, "Test debug log"); Log.e(LOG_TAG, "Test error log"); 

, , MainActivity, , .

निष्कर्ष

, Android. , , , : , . , , - Android-.