რა არის ანდროიდის აქტივობები და როგორია მათი სასიცოცხლო ციკლი?

მობილური აპლიკაციების შემუშავების ერთ-ერთი მთავარი კონცეფციაა Activity კონცეფცია, ეს არის აპლიკაციის საფუძველი, ამჯერად ვნახავთ რისგან შედგება და როგორია მათი სასიცოცხლო ციკლი.

Android-ის დეველოპერის ოფიციალურ გვერდზე ჩვენ შეგვიძლია ვიპოვოთ უფრო დეტალური ახსნა, თუ რას წარმოადგენს აქტივობები (https://developer.android.com/guide/components/activities/intro-activities) აქ დავინახავთ მათ და მათ სასიცოცხლო ციკლს.

ჩვენ უკვე ვნახეთ, რომ Android აპლიკაცია შედგება სხვადასხვა გრაფიკული კომპონენტებისგან ან ხედებისგან და, გარდა ამისა, მათ აქვთ დირექტორია სტრუქტურა, რომელიც საშუალებას აძლევს გრაფიკულ ინტერფეისს იყოს დამოუკიდებელი აპლიკაციის ლოგიკისაგან, ეკრანები იმართება xml ფაილების მეშვეობით, რომლებიც შეიცავს განლაგება ან კონტენტის მენეჯერები და ლოგიკაზე მუშაობენ აქტივობები, რომლებიც შეესაბამება აქტივობის კლასს, ასევე არის კიდევ ერთი კონცეფცია, რომელსაც ეწოდება ფრაგმენტები, რომლებიც ცხოვრობენ აქტივობების შიგნით, მაგრამ ეს არის ის, რასაც მოგვიანებით შევეხებით.

აქტივობის კლასი აპლიკაციის ერთ-ერთი მთავარი კომპონენტია. ისინი სწორედ აპლიკაციების შექმნის საფუძველს წარმოადგენენ, რადგან ისინი მართავენ სისტემურ ლოგიკას და რასთან ურთიერთქმედებს მომხმარებელი. Android აპლიკაცია იწყება აქტივობის მაგალითით, რომელსაც აქვს განსაზღვრული სასიცოცხლო ციკლი აპლიკაციის გასაშვებად.

სასიცოცხლო ციკლში ჩასვლამდე ძალიან მნიშვნელოვანია იმის გარკვევა, რომ მობილური აპლიკაციის ფუნქციონირება განსხვავდება სხვა აპლიკაციების ფუნქციონირებისგან, მობილურ აპლიკაციას არ აქვს კონკრეტული საწყისი წერტილი, განსხვავებით დესკტოპის აპლიკაციისგან, რომელიც იწყება მთავარი ( ) მეთოდით, აპლიკაციის გაშვება შესაძლებელია მისი ნებისმიერი ეკრანიდან (ეს არ ნიშნავს, რომ ჩვენ არ შეგვიძლია დაწყების შეკვეთის მიცემა).

შინაგანად, როდესაც ჩვენ ვცვლით ეკრანებს, კეთდება ზარი აქტივობებს შორის (ან ფრაგმენტები იცვლება იმავე აქტივობაში) და როდესაც ჩვენ ვცვლით აპლიკაციებს შორის იმავე გზით, აპლიკაცია გამოძახებულია მისი საწყისი აქტივობის გამოძახებით.

აპლიკაცია ჩვეულებრივ შედგება რამდენიმე ეკრანისგან, რაც უდრის რამდენიმე აქტივობის ქონას, რომლებიც ურთიერთობენ ერთმანეთთან, თუმცა უკვე აღინიშნა, რომ აპლიკაციის გაშვება შესაძლებელია ნებისმიერი აქტივობიდან, აქტივობა ყოველთვის განისაზღვრება, როგორც მთავარი აქტივობა MainActivity ( თუმცა არ უნდა იყოს აუცილებლად პირველი, რომელიც გამოჩნდება) და იქიდან მონიშნეთ სისტემაში ნავიგაციის საწყისი წერტილი ახალი აქტივობების ან ფრაგმენტების გამოძახებით.

Manifest ფაილი (AndroidManifest.xml)

წინა ჩანაწერში ჩვენ ვისაუბრეთ მანიფესტის ფაილზე, ეს არის კონფიგურაციის ფაილი, რომელიც საშუალებას გაძლევთ პარამეტრიზაცია მოახდინოთ აპლიკაციის ძირითად ელემენტებზე, აქ ნახავთ ინფორმაციას, როგორიცაა განაცხადის ID, სახელი, ხატულა, მასში შემავალი აქტივობები, ნებართვები, სხვა მნიშვნელოვან საკითხებთან ერთად.

როდესაც აქტივობა იქმნება, androidStudio ავტომატურად ზრუნავს მის პარამეტრიზაციაზე AndroidManifest.xml ფაილში და შემდეგ ასევე შეგიძლიათ დაამატოთ ფილტრები ან თვისებები აპლიკაციის დამატებითი მოქმედებების დასადგენად, მაგალითად, წინა სურათზე ხედავთ, რომ MainActivity არის ძირითადი საქმიანობის სისტემა (პირველი ნაჩვენები) მას შემდეგ, რაც ემატება მას ქონებით

აქტივობის სასიცოცხლო ციკლი.

აქტივობა გადის რამდენიმე მდგომარეობას მისი შესრულების დროს, ეს მდგომარეობები წარმოიქმნება მომხმარებლის აქტივობასთან ურთიერთქმედებით, მაგალითად, როდესაც ის შედის, გადის, ისევ შედის ან დახურულია, ანდროიდი გვაძლევს საშუალებას ვაკონტროლოთ თითოეული ეს მდგომარეობა მთელი რიგის საშუალებით. განსაზღვრული მეთოდები, რომლებიც შეგვიძლია განვახორციელოთ ქცევის სამართავად, მაგალითად, შეგიძლიათ დააპაუზოთ ვიდეო პლეერი ეკრანის შეცვლისას ან გააუქმოთ კავშირის პროცესები აპლიკაციიდან გასვლისას, ანდროიდის დეველოპერის გვერდზე ვპოულობთ ამ მეთოდების დეტალებს (აქ ასევე შეგვიძლია ვიპოვოთ შემდეგი დიაგრამა, რომელიც აჩვენებს, თუ როგორ მუშაობს:

მოდით ვნახოთ თითოეული სახელმწიფოს შეჯამება:

• onCreate ()

  ეს მეთოდი ნაგულისხმევად იქმნება აქტივობაში და გააქტიურებულია, როდესაც ის იწყებს გრაფიკული ნაწილის შესაბამისი განლაგების მითითებას setContentView() მეთოდის საშუალებით, ეს არის პირველი მეთოდი, რომელიც შესრულებულია.

• onStart()

  როდესაც onCreate() დახურულია, აქტივობა ცვლის თავის მდგომარეობას შექმნილიდან დაწყებულამდე და წარედგინება მომხმარებელს, სწორედ აქ ხდება ხედვა და აქტივობა ინტერაქტიული.

• Მოკლედ()

  აქტივობის დაწყების შემდეგ იცვლება onResume() მდგომარეობა, რომელიც პასუხისმგებელია მომხმარებლის ურთიერთქმედების ინფორმაციის დამუშავებაზე, აქ ყველაფერი, რასაც მომხმარებელი შეაქვს, აღიარებულია და აღირიცხება.

• onPause ()

  თუ აქტივობა კარგავს ფოკუსს და წყდება, პაუზის მდგომარეობა გამოიძახება, მაგალითად, როდესაც მომხმარებელი დააჭერს უკანა ღილაკს ან ცვლის ეკრანს, ეს ნიშნავს, რომ აქტივობა ნაწილობრივ მაინც ჩანს აქტივობის დახურვისას.

  ამ მდგომარეობიდან შეგიძლიათ კვლავ დაუბრუნდეთ onResume() ან onStop()

• onStop ()

  ეს მდგომარეობა იწყება მაშინ, როდესაც აქტივობა აღარ არის მომხმარებლისთვის ხილული, ეს შეიძლება იყოს იმის გამო, რომ აქტივობა წაშლილია, შეჩერებული აქტივობა ხელახლა აქტიურდება ან ახალი იწყება, ამ შემთხვევაში შეწყვეტილი აქტივობა აღარ ჩანს მომხმარებელი. მომხმარებელი, აქედან შეგიძლიათ დარეკოთ onRestart() ან onDestroy()

• on Restart()

  სისტემა შედის ამ მდგომარეობაში, როდესაც შეჩერებული აქტივობა ხელახლა დაიწყება, აქ აქტივობის მდგომარეობა აღდგება შეწყვეტის მომენტიდან და განხორციელდება ზარი onStart()-ზე.

• onDestroy()

  და ბოლოს, სისტემა უწოდებს ამ მეთოდს აქტივობის წაშლამდე, ეს არის ბოლო მდგომარეობა, რომელსაც გადის აქტივობა და განხორციელდება, როდესაც გარანტირებული უნდა იყოს აქტივობის ყველა რესურსის დახურვა ან გათავისუფლება.

ეს მეთოდები შეიძლება განხორციელდეს პროექტში შემდეგნაირად:

ასე რომ, აპლიკაციის გაშვებისას ჩვენ დავინახავთ ქცევას logcat-ში.

და ეს ასეა, ამით ჩვენ ვხედავთ რისგან შედგება აქტივობები და როგორ შეგვიძლია ვაკონტროლოთ სასიცოცხლო ციკლი, შემდეგ შეგვიძლია გავაგრძელოთ მუშაობა ძირითად აპლიკაციაზე.

შეიძლება ასევე დაგაინტერესოთ.

არის რაიმე რისი დამატება ან კომენტარის გაკეთება ამ ჩანაწერის შესახებ? თავისუფლად გააკეთე….და თუ მოგეწონათ... გეპატიჟებით გააზიაროთ ი გამოიწერეთ ღილაკზე „შეუერთდით ამ საიტზე“ დაწკაპუნებით, რომ მოისმინოთ მეტი მსგავსი პოსტი 😉