Android కార్యాచరణ లైఫ్ సైకిల్ అంటే ఏమిటి?

ఆండ్రాయిడ్ అనేది ఓపెన్ సోర్స్ ఆపరేటింగ్ సిస్టమ్, ఇది చాలా పనులకు ఉపయోగపడుతుంది. మీరు ప్రారంభించినప్పుడు లేదా తెరిచినప్పుడు , ఇది వివిధ రాష్ట్రాలకు లోనవుతుంది మరియు దీనిని Android కార్యాచరణ లైఫ్ సైకిల్ అంటారు.

ఈ వ్యాసంలో క్రింద విషయాలు ఉన్నాయి:

• Android పరిచయం
  
• Android కార్యాచరణ లైఫ్ సైకిల్ అంటే ఏమిటి?
  
• లైఫ్ సైకిల్ పద్ధతులు మరియు కాల్‌బ్యాక్‌లు
  
• డెమో: కార్యాచరణ లైఫ్‌సైకిల్‌ను అమలు చేయండి

ప్రారంభిద్దాం!

Android పరిచయం

Android ఓపెన్ సోర్స్ ఆపరేటింగ్ సిస్టమ్, ఇది a తో Linux పై ఆధారపడి ఉంటుంది స్మార్ట్‌ఫోన్‌ల వంటి మొబైల్ పరికరాల కోసం ఇంటర్‌ఫేస్ (Android OS కి మద్దతు ఇచ్చే టచ్ స్క్రీన్ పరికరాలు).

ఇది బహుళ API ని కలిగి ఉంటుందిGPS వంటి స్థాన-ఆధారిత సేవలకు మద్దతు ఇవ్వడానికి. ఇది కూడాకెమెరా మరియు మైక్రోఫోన్ ఉపయోగించి ప్లేబ్యాక్ లేదా రికార్డింగ్ చేయడానికి మల్టీమీడియా హార్డ్‌వేర్ నియంత్రణకు విస్తృతమైన మద్దతు ఉంది. ఇది మల్టీ-టాస్కింగ్‌కు మద్దతు ఇస్తుంది, మేము ఒక టాస్క్ విండో నుండి మరొకదానికి తరలించగలము మరియు బహుళ అనువర్తనాలు ఏకకాలంలో అమలు చేయగలవు ఇది అనువర్తన భాగాలను తిరిగి ఉపయోగించటానికి మరియు స్థానిక అనువర్తనాల పున ment స్థాపనకు అవకాశం ఇస్తుంది.

దీనితో, మరింత ముందుకు వెళ్లి, Android కార్యాచరణ జీవిత చక్రం ఏమిటో తెలుసుకుందాం.

Android కార్యాచరణ లైఫ్ సైకిల్ అంటే ఏమిటి?

అనువర్తనం ద్వారా వినియోగదారు నావిగేట్ చేస్తున్నప్పుడు, కార్యాచరణ మీ జీవిత చక్రంలో వివిధ దశల ద్వారా మీ అనువర్తన పరివర్తనలోని సందర్భాలు. కార్యాచరణ తరగతి ఒక రాష్ట్రం మారిందని తెలుసుకోవటానికి అనుమతించే అనేక కాల్‌బ్యాక్‌లను అందిస్తుంది: సిస్టమ్ ఒక కార్యాచరణను సృష్టించడం, ఆపడం లేదా పున uming ప్రారంభించడం లేదా కార్యాచరణ నివసించే ప్రక్రియను నాశనం చేయడం.

ఇప్పుడు జీవిత కార్యాచరణ పద్ధతులు మరియు కాల్‌బ్యాక్‌ల సహాయంతో Android కార్యాచరణ లైఫ్ సైకిల్‌ను మరింత వివరంగా తెలుసుకుందాం.

లైఫ్ సైకిల్ పద్ధతులు మరియు కాల్‌బ్యాక్‌లు

సాధారణంగా, కార్యాచరణ జీవితచక్రంలో ఏడు బ్యాక్ పద్ధతులు ఉన్నాయి:

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

ఇప్పుడు Android కార్యాచరణ లైఫ్ సైకిల్ పద్ధతులు మరియు కాల్‌బ్యాక్‌ల వివరాలను తెలుసుకుందాం. జీవిత చక్రాన్ని అర్థం చేసుకోవడానికి ఈ క్రింది బొమ్మను చూడండి.

వివిధ ప్రోగ్రామింగ్ భాషలలోని ప్రధాన () ఫంక్షన్ నుండి ప్రోగ్రామ్ మొదలవుతుందని మీకు తెలుసు. అదేవిధంగా, ఆండ్రాయిడ్ కాల్‌తో కార్యాచరణలో ప్రోగ్రామ్‌ను ప్రారంభిస్తుంది onCreate () బ్యాక్ పద్ధతి. కాల్‌బ్యాక్ పద్ధతుల క్రమం ఉంది, అది ఒక కార్యాచరణను ప్రారంభించి, ఆపై పైన పేర్కొన్న కార్యాచరణ జీవిత చక్ర రేఖాచిత్రంలో చూపిన విభిన్న పద్ధతుల్లో కూల్చివేస్తుంది:

1. onCreate () :ఈ స్థితిలో, కార్యాచరణ సృష్టించబడుతుంది.

2. ఆన్‌స్టార్ట్ (): కార్యాచరణ వినియోగదారుకు కనిపించినప్పుడు ఈ బ్యాక్ పద్ధతిని పిలుస్తారు.

3. onResume () :కార్యాచరణ ముందుభాగంలో ఉంది మరియు వినియోగదారు దానితో సంభాషించవచ్చు.

4. onPause () :కార్యాచరణ మరొక కార్యాచరణ ద్వారా పాక్షికంగా అస్పష్టంగా ఉంటుంది. ముందు భాగంలో ఉన్న మరొక కార్యాచరణ సెమీ పారదర్శకంగా ఉంటుంది.

5. ఆన్‌స్టాప్ () :కార్యాచరణ పూర్తిగా దాచబడింది మరియు వినియోగదారుకు కనిపించదు.

6. ఆన్ రిస్టార్ట్ (): ఆగిపోయిన స్థితి నుండి, కార్యాచరణ వినియోగదారుతో సంభాషించడానికి తిరిగి వస్తుంది లేదా కార్యాచరణ అమలు అయిపోయి వెళ్లిపోతుంది. కార్యాచరణ తిరిగి వస్తే, సిస్టమ్ ప్రారంభమవుతుంది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 తరగతి కాల్‌బ్యాక్ పద్ధతులను ఫైల్ చేయండి మరియు భర్తీ చేయండి. దీన్ని విస్తృత గేజ్‌లో అర్థం చేసుకోవడానికి క్రింది కోడ్‌ను చూద్దాం.

ప్యాకేజీ com.example.activitycycle దిగుమతి androidx.appcompat.app.AppCompatActivity import android.os.Bundle import android.util.Log import android.widget.Toast class MainActivity: AppCompatActivity () fun సరదాగా ఓవర్‌రైడ్ చేయండి (సేవ్ఇన్‌స్టాన్స్‌స్టేట్) .onCreate (saveInstanceState) setContentView (R.layout.activity_main) print ('*** App state: OnCreate *** n') Toast.makeText (getApplicationContext (), 'App state: OnCreate', Toast.LENGTH_LONG) .షో () on సరదాగా ఓవర్‌స్టార్ట్ () {super.onStart () ముద్రణ ('*** అనువర్తన స్థితి: ఆన్‌స్టార్ట్ *** n') Toast.makeText (getApplicationContext (), 'App state: OnStart', Toast.LENGTH_LONG). చూపించు () fun సరదాగా పున r ప్రారంభించండి () {super.onResume () ముద్రణ ('*** అనువర్తన స్థితి: OnResume *** n') Toast.makeText (getApplicationContext (), 'App state: OnResume', Toast.LENGTH_LONG) .షో () fun ఆన్‌స్టాప్ () {super.onStop () ముద్రణ ('*** అనువర్తన స్థితి: ఆన్‌స్టాప్ *** n') Toast.makeText (getApplicationContext (), 'App state: OnStop', Toast.LENGTH_LONG ) .షో () fun ఫన్ ఆన్ పాస్ () {super.onPause () ప్రింట్ ('*** అనువర్తనం state: OnPause *** n ') Toast.makeText (getApplicationContext (),' App state: OnPause ', Toast.LENGTH_LONG) .షో () fun సరదాగా పున r ప్రారంభించండి () {super.onRestart () ముద్రణ (' *** అనువర్తన స్థితి: OnReStart *** n ') Toast.makeText (getApplicationContext (),' App state: OnRestart ', Toast.LENGTH_LONG) .షో () fun సరదాగా ఓవర్‌రైడ్ onDestroy () {super.onDestroy () ముద్రణ (' ** * అనువర్తన స్థితి: OnDestroy *** n ') Toast.makeText (getApplicationContext (),' App state: OnDestroy ', Toast.LENGTH_LONG) .షో ()}}

సాధారణంగా, పై ఉదాహరణలో, నేను అన్ని పద్ధతులను అధిగమిస్తున్నాను మరియు రాష్ట్రాలను ముద్రించాను. అలాగే, నేను ఉపయోగించానుToast.makeText (), అనువర్తనంలోనే జీవిత చక్ర పద్ధతులను ప్రదర్శించడానికి. అనువర్తనం వివిధ రాష్ట్రాల గుండా వెళ్ళినప్పుడల్లా, ఇది అనువర్తనంలోనే పద్ధతులను అమలు చేస్తుంది మరియు ప్రదర్శిస్తుంది. Android కార్యాచరణ జీవిత చక్రం ఎలా పనిచేస్తుంది. మీరు Android యొక్క ప్రాథమికాలను తెలుసుకోవాలనుకుంటే, దయచేసి ఈ కథనాన్ని తనిఖీ చేయండి .

ఇది Android కార్యాచరణ లైఫ్ సైకిల్‌పై ఈ వ్యాసం చివరకి తీసుకువస్తుంది.ఈ వ్యాసంలో మీతో పంచుకున్న అన్ని విషయాలతో మీరు స్పష్టంగా ఉన్నారని ఆశిస్తున్నాము.

ఇప్పుడు మీరు మా కోట్లిన్ ఆండ్రాయిడ్ ట్యుటోరియల్ ద్వారా వెళ్ళారు, మీరు ఎడురేకాను చూడవచ్చు మాకు ప్రశ్న ఉందా? దయచేసి ”Android కార్యాచరణ లైఫ్ సైకిల్” బ్లాగ్ విభాగం యొక్క వ్యాఖ్యలలో పేర్కొనండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.