Android செயல்பாட்டு வாழ்க்கை சுழற்சி என்றால் என்ன?

ஒரு பயனர் பயன்பாட்டின் வழியாக செல்லும்போது, ​​உங்கள் பயன்பாட்டு சுழற்சியின் செயல்பாட்டு நிகழ்வுகள் அவர்களின் வாழ்க்கைச் சுழற்சியில் வெவ்வேறு கட்டங்களில் செல்கின்றன. இந்த கட்டுரையில், Android செயல்பாட்டு வாழ்க்கை சுழற்சி நிலைகளைப் பற்றி பேசுவேன்.

அண்ட்ராய்டு என்பது திறந்த மூல இயக்க முறைமையாகும், இது பல பணிகளுக்கு பயனுள்ளதாக இருக்கும். நீங்கள் தொடங்கும்போது அல்லது திறக்கும்போது , இது பல்வேறு மாநிலங்களுக்கு உட்படும், அது Android செயல்பாட்டு வாழ்க்கை சுழற்சி என அழைக்கப்படுகிறது.

இந்த கட்டுரையில் தலைப்புகள் கீழே உள்ளன:



தொடங்குவோம்!

Android அறிமுகம்

Android ஒரு திறந்த மூல இயக்க முறைமையாகும், இது லினக்ஸை அடிப்படையாகக் கொண்டது ஸ்மார்ட்போன்கள் போன்ற மொபைல் சாதனங்களுக்கான இடைமுகம் (Android OS ஐ ஆதரிக்கும் தொடுதிரை சாதனங்கள்).

Android -Android Activity Life Cycle - Edureka இது பல API ஐ கொண்டுள்ளதுஜி.பி.எஸ் போன்ற இருப்பிட அடிப்படையிலான சேவைகளை ஆதரிக்க. அதுவும்கேமரா மற்றும் மைக்ரோஃபோனைப் பயன்படுத்தி பிளேபேக் அல்லது ரெக்கார்டிங் செய்ய மல்டிமீடியா வன்பொருள் கட்டுப்பாட்டுக்கு விரிவான ஆதரவு உள்ளது. இது பல பணிகளை ஆதரிக்கிறது, நாம் ஒரு பணி சாளரத்திலிருந்து இன்னொரு இடத்திற்கு செல்லலாம் மற்றும் பல பயன்பாடுகள் ஒரே நேரத்தில் இயங்க முடியும் இது பயன்பாட்டு கூறுகளை மீண்டும் பயன்படுத்தவும், சொந்த பயன்பாடுகளை மாற்றவும் ஒரு வாய்ப்பை வழங்கும்.

இதன் மூலம், மேலும் முன்னேறி, Android செயல்பாட்டு வாழ்க்கைச் சுழற்சி என்ன என்பதை அறிவோம்.

Android செயல்பாட்டு வாழ்க்கை சுழற்சி என்றால் என்ன?

பயன்பாட்டின் மூலம் ஒரு பயனர் செல்லும்போது, நடவடிக்கை உங்கள் வாழ்க்கைச் சுழற்சியில் வெவ்வேறு கட்டங்களில் உங்கள் பயன்பாட்டின் மாற்றத்தின் நிகழ்வுகள். செயல்பாட்டு வகுப்பு ஒரு நிலை மாறிவிட்டது என்பதை அறிய செயல்பாட்டை அனுமதிக்கும் பல கால்பேக்குகளை வழங்குகிறது: கணினி ஒரு செயல்பாட்டை உருவாக்குகிறது, நிறுத்துகிறது, அல்லது மீண்டும் தொடங்குகிறது, அல்லது செயல்பாடு வாழும் செயல்முறையை அழிக்கிறது.

இப்போது வாழ்க்கைச் சுழற்சி முறைகள் மற்றும் கால்பேக்குகளின் உதவியுடன் Android செயல்பாட்டு வாழ்க்கை சுழற்சியை இன்னும் விரிவாக அறிந்து கொள்வோம்.

வாழ்க்கை சுழற்சி முறைகள் மற்றும் கால்பேக்குகள்

பொதுவாக, செயல்பாட்டு வாழ்க்கை சுழற்சியில் ஏழு அழைப்பு முறைகள் உள்ளன:

  1. onCreate ()
  2. onStart ()
  3. onResume ()
  4. onPause ()
  5. onStop ()
  6. onRestart ()
  7. onDestroy ()

இப்போது Android செயல்பாட்டு வாழ்க்கை சுழற்சி முறைகள் மற்றும் கால்பேக்குகளின் விவரங்களைப் பெறுவோம். வாழ்க்கைச் சுழற்சியைப் புரிந்துகொள்ள கீழேயுள்ள படத்தைப் பாருங்கள்.

வெவ்வேறு நிரலாக்க மொழிகளில் ஒரு முக்கிய () செயல்பாட்டிலிருந்து ஒரு நிரல் தொடங்குகிறது என்பதை நீங்கள் அறிந்திருக்க வேண்டும். இதேபோல், அண்ட்ராய்டு ஒரு அழைப்புடன் ஒரு செயல்பாட்டிற்குள் நிரலைத் தொடங்குகிறது onCreate () திரும்ப அழைக்கும் முறை. திரும்பப்பெறுதல் முறைகளின் வரிசை உள்ளது, அது ஒரு செயல்பாட்டைத் தொடங்குகிறது, பின்னர் மேலே உள்ள செயல்பாட்டு வாழ்க்கை சுழற்சி வரைபடத்தில் காட்டப்பட்டுள்ள வெவ்வேறு முறைகளில் கிழிக்கப்படுகிறது:

ஜாவாவில் கருத்து வகைகள்

1. onCreate () :இந்த நிலையில், செயல்பாடு உருவாக்கப்படுகிறது.

2. onStart (): செயல்பாடு பயனருக்குத் தெரியும் போது இந்த அழைப்பு முறை அழைக்கப்படுகிறது.

3. onResume () :செயல்பாடு முன்னணியில் உள்ளது மற்றும் பயனர் அதனுடன் தொடர்பு கொள்ளலாம்.

4. onPause () :செயல்பாடு மற்றொரு செயலால் ஓரளவு மறைக்கப்படுகிறது. முன்னணியில் இருக்கும் மற்றொரு செயல்பாடு அரை வெளிப்படையானது.

5. onStop () :செயல்பாடு முற்றிலும் மறைக்கப்பட்டுள்ளது மற்றும் பயனருக்குத் தெரியவில்லை.

6. onRestart (): நிறுத்தப்பட்ட நிலையிலிருந்து, செயல்பாடு பயனருடன் தொடர்புகொள்வதற்கு மீண்டும் வரும் அல்லது செயல்பாடு இயங்குவதை முடித்துவிட்டு விலகிச் செல்கிறது. செயல்பாடு மீண்டும் வந்தால், கணினி செயல்படுத்துகிறதுonRestart ()

7. onDestroy (): செயல்பாடு அழிக்கப்பட்டு நினைவகத்திலிருந்து அகற்றப்படும்.

எனவே இவை செயல்பாட்டு வாழ்க்கை சுழற்சியின் பல்வேறு முறைகள். வாழ்க்கைச் சுழற்சி முறைகள் மற்றும் நிலைகள் ஏற்படும் சூழ்நிலைகளை இப்போது பார்ப்போம்.

  • நீங்கள் பயன்பாட்டைத் திறக்கும்போது அது கீழ்க்கண்ட மாநிலங்களில் செல்லும்:

onCreate () -> onStart () -> onResume ()

  • பின் பொத்தானை அழுத்தி பயன்பாட்டிலிருந்து வெளியேறும்போது

    onPaused () -> onStop () -> onDestory ()

  • முகப்பு பொத்தானை அழுத்தும்போது

    onPaused () -> onStop ()

  • முகப்பு பொத்தானை அழுத்திய பின், சமீபத்திய பணி பட்டியலிலிருந்து பயன்பாட்டைத் திறக்கும்போது

    ஜாவாவில் எண்ணை எவ்வாறு மாற்றுவது

    onRestart () -> onStart () -> onResume ()

  • உரையாடலில் இருந்து உரையாடல் அல்லது பின் பொத்தானை நிராகரித்த பிறகு

    onResume ()

  • ஒரு தொலைபேசி ஒலிக்கிறது மற்றும் பயனர் பயன்பாட்டைப் பயன்படுத்துகிறார் என்றால்

    onPause () -> onResume ()

  • அழைப்பு முடிந்ததும்

    onResume ()

  • உங்கள் தொலைபேசி திரை முடக்கப்பட்டிருக்கும் போது

    onPaused () -> onStop ()

  • உங்கள் தொலைபேசி திரை மீண்டும் இயக்கப்படும் போது

    onRestart () -> onStart () -> onResume ()

எனவே உங்கள் பயன்பாடு பல்வேறு மாநிலங்களில் செல்லும்போது இவை சில சூழ்நிலைகள். கீழேயுள்ள உதாரணத்தின் உதவியுடன் இதை எவ்வாறு செயல்படுத்தலாம் என்பதை இப்போது பார்ப்போம்.

டெமோ: செயல்பாட்டு வாழ்க்கை சுழற்சியை செயல்படுத்தவும்

படி 1: முதலில் நீங்கள் ஒரு எளிய Android பயன்பாட்டை உருவாக்க வேண்டும் அல்லது கோட்லின் புரோகிராமிங் மொழி . இந்த டெமோவில், நான் கோட்லின் நிரலாக்க மொழியைப் பயன்படுத்துகிறேன், ஏனெனில் ஜாவாவுடன் ஒப்பிடும்போது கோட்லின் குறைவான எண்ணிக்கையிலான குறியீடுகளைக் கொண்டுள்ளது. ஜாவாவைப் பயன்படுத்தி Android பயன்பாட்டை எவ்வாறு உருவாக்குவது என்பதை நீங்கள் அறிய விரும்பினால், தயவுசெய்து பார்க்கவும் . மேலும், நீங்கள் கோட்லினைப் பயன்படுத்தி Android பயன்பாட்டை உருவாக்க விரும்பினால், இந்த கட்டுரையைப் பாருங்கள் .

ஜாவாவில் இடையக ரீடர் என்ன செய்கிறது

படி 2: உங்கள் பயன்பாட்டை உருவாக்கியதும், உங்கள் உள்ளமைக்க வேண்டும் MainActivity.kt வகுப்பு கோல்பேக் முறைகளை கோப்பு மற்றும் மேலெழுதவும். இதை ஒரு பரந்த அளவிலான புரிந்து கொள்ள கீழே உள்ள குறியீட்டைப் பார்ப்போம்.

தொகுப்பு. . () fun onStart () {super.onStart () அச்சு ('*** பயன்பாட்டு நிலை: OnStart *** n') Toast.makeText (getApplicationContext (), 'பயன்பாட்டு நிலை: OnStart', Toast.LENGTH_LONG). show () fun வேடிக்கை மேலெழுதும் onResume () {super.onResume () அச்சு ('*** பயன்பாட்டு நிலை: OnResume *** n') Toast.makeText (getApplicationContext (), 'பயன்பாட்டு நிலை: OnResume', Toast.LENGTH_LONG) .show () fun வேடிக்கை onStop () {super.onStop () அச்சு ('*** பயன்பாட்டு நிலை: OnStop *** n') Toast.makeText (getApplicationContext (), 'பயன்பாட்டு நிலை: OnStop', Toast.LENGTH_LONG ) .ஷோ () fun வேடிக்கையை மேலெழுதும் onPause () {super.onPause () அச்சு ('*** பயன்பாடு state: OnPause *** n ') Toast.makeText (getApplicationContext (),' பயன்பாட்டு நிலை: OnPause ', Toast.LENGTH_LONG) .ஷோ () fun வேடிக்கையை மீறவும் onRestart () {super.onRestart () அச்சு (' *** பயன்பாட்டு நிலை: OnReStart *** n ') Toast.makeText (getApplicationContext (),' பயன்பாட்டு நிலை: OnRestart ', Toast.LENGTH_LONG) .ஷோ () fun வேடிக்கையை மேலெழுதும் onDestroy () {super.onDestroy () அச்சு (' ** * பயன்பாட்டு நிலை: OnDestroy *** n ') Toast.makeText (getApplicationContext (),' பயன்பாட்டு நிலை: OnDestroy ', Toast.LENGTH_LONG) .ஷோ ()}}

அடிப்படையில், மேலே உள்ள எடுத்துக்காட்டில், நான் எல்லா முறைகளையும் மீறி மாநிலங்களை அச்சிடுகிறேன். மேலும், நான் பயன்படுத்தினேன்Toast.makeText (), பயன்பாட்டிலேயே வாழ்க்கைச் சுழற்சி முறைகளைக் காண்பிக்க. பயன்பாடு பல்வேறு மாநிலங்களில் செல்லும் போதெல்லாம், அது பயன்பாட்டில் உள்ள முறைகளை செயல்படுத்துகிறது மற்றும் காண்பிக்கும். Android செயல்பாட்டு வாழ்க்கைச் சுழற்சி செயல்படுகிறது. Android இன் அடிப்படைகளை நீங்கள் அறிய விரும்பினால், தயவுசெய்து இந்த கட்டுரையை சரிபார்க்கவும் .

இது Android செயல்பாட்டு வாழ்க்கை சுழற்சியில் இந்த கட்டுரையின் முடிவிற்கு நம்மைக் கொண்டுவருகிறது.இந்த கட்டுரையில் உங்களுடன் பகிரப்பட்ட எல்லாவற்றிலும் நீங்கள் தெளிவாக இருப்பீர்கள் என்று நம்புகிறேன்.

இப்போது நீங்கள் எங்கள் கோட்லின் ஆண்ட்ராய்டு டுடோரியலைப் பார்த்திருக்கிறீர்கள், நீங்கள் எடுரேகாவைப் பார்க்கலாம் எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? 'Android செயல்பாட்டு வாழ்க்கை சுழற்சி' வலைப்பதிவு பிரிவின் கருத்துகளில் இதைக் குறிப்பிடவும், நாங்கள் உங்களைத் தொடர்புகொள்வோம்.