Activity Lifecycle: τι είναι, onCreate onStart onResume στο Android

Τι είναι το Activity Lifecycle

Activity Lifecycle (κύκλος ζωής Activity) — μια πεπερασμένη μηχανή καταστάσεων από την οποία περνά κάθε οθόνη μιας εφαρμογής Android από τη στιγμή της δημιουργίας έως την πλήρη καταστροφή. Το σύστημα Android διαχειρίζεται αυτή τη διαδικασία βάσει των ενεργειών του χρήστη: άνοιγμα εφαρμογής, ελαχιστοποίηση, περιστροφή οθόνης, απάντηση σε εισερχόμενη κλήση, εναλλαγή μεταξύ εφαρμογών και τερματισμός.

Η κατανόηση του κύκλου ζωής είναι απαραίτητη για κάθε προγραμματιστή Android, επειδή το σύστημα μπορεί ανά πάσα στιγμή να καταστρέψει το Activity σε περίπτωση έλλειψης μνήμης — και η εφαρμογή οφείλει να επαναφέρει σωστά την κατάστασή της. Σύμφωνα με τα δεδομένα Google Android Vitals (2025), οι εφαρμογές που δεν διαχειρίζονται την αποθήκευση κατάστασης στο onSaveInstanceState() εμφανίζουν 42% περισσότερα crashes κατά την αναδημιουργία Activity.

Ο κύκλος ζωής περιλαμβάνει έξι βασικές μεθόδους callback: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy(). Επιπλέον, υπάρχει η μέθοδος onRestart() που καλείται πριν από το onStart() όταν το Activity επιστρέφει από σταματημένη κατάσταση. Κάθε μέθοδος έχει αυστηρά καθορισμένο σκοπό και χρόνο εκτέλεσης — το σύστημα τις καλεί σειριακά και ο προγραμματιστής μπορεί να παρακάμψει οποιαδήποτε από αυτές για να εκτελέσει τη δική του λογική.

Ο κύκλος μπορεί να χωριστεί σε τρία βασικά στάδια: ολόκληρη η διάρκεια ζωής (onCreate → onDestroy), ορατή διάρκεια ζωής (onStart → onStop) και διάρκεια ζωής στο προσκήνιο (onResume → onPause). Η κατανόηση αυτών των τριών επιπέδων βοηθά στη σωστή κατανομή του κώδικα αρχικοποίησης και απελευθέρωσης πόρων.

Μέθοδοι κύκλου ζωής Activity

Κάθε μέθοδος κύκλου ζωής εκτελεί αυστηρά καθορισμένη εργασία. Το σύστημα τις καλεί σε σταθερή σειρά και ο προγραμματιστής πρέπει να παρακάμπτει μόνο εκείνες τις μεθόδους που χρειάζονται για τη συγκεκριμένη λογική. Δεν συνιστάται η άμεση κλήση μεθόδων κύκλου ζωής — αυτό το κάνει το Android Runtime.

Γενικό σχήμα κλήσεων

Τυπική ακολουθία κατά την εκκίνηση εφαρμογής: onCreate → onStart → onResume. Κατά το πάτημα του κουμπιού «Πίσω»: onPause → onStop → onDestroy. Κατά την ελαχιστοποίηση: onPause → onStop, στη συνέχεια κατά την επιστροφή: onRestart → onStart → onResume.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
    }

    override fun onResume() {
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
    }

    override fun onStop() {
        super.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    override fun onRestart() {
        super.onRestart()
    }
}

Κάθε παρακαμφθείσα μέθοδος πρέπει να καλεί την super έκδοση — χωρίς αυτό, το σύστημα δεν μπορεί να ολοκληρώσει σωστά τη μετάβαση μεταξύ καταστάσεων. Αυτός ο κανόνας είναι κατοχυρωμένος στην τεκμηρίωση Android Developers και ελέγχεται από τους κανόνες lint του Android Studio.

Τρία επίπεδα κύκλου ζωής

Πρώτο επίπεδο — ολόκληρη η διάρκεια ζωής (entire lifetime): το διάστημα μεταξύ onCreate και onDestroy. Εδώ γίνεται εφάπαξ αρχικοποίηση και τελική απελευθέρωση καθολικών πόρων. Δεύτερο επίπεδο — ορατή διάρκεια ζωής (visible lifetime): μεταξύ onStart και onStop. Το Activity είναι ορατό στην οθόνη, αλλά μπορεί να καλύπτεται εν μέρει από άλλο παράθυρο. Τρίτο επίπεδο — διάρκεια ζωής στο προσκήνιο (foreground lifetime): μεταξύ onResume και onPause. Το Activity βρίσκεται στην κορυφή της στοίβας εργασιών και αλληλεπιδρά με τον χρήστη.

onCreate — δημιουργία Activity

onCreate() — η πρώτη και μοναδική υποχρεωτική μέθοδος του κύκλου ζωής Activity. Καλείται μία φορά από το σύστημα κατά τη δημιουργία μιας παρουσίας Activity. Αυτή η μέθοδος λαμβάνει την παράμετρο savedInstanceState: Bundle? που περιέχει την προηγουμένως αποθηκευμένη κατάσταση, αν το Activity αναδημιουργείται μετά από καταστροφή — για παράδειγμα, κατά την περιστροφή οθόνης.

Μέσα στο onCreate εκτελούνται οι ακόλουθες εργασίες: αρχικοποίηση της διεπαφής χρήστη μέσω setContentView() με μεταβίβαση του πόρου layout, σύνδεση στοιχείων View μέσω findViewById(), ρύθμιση προσαρμογέων για RecyclerView και ViewPager, επαναφορά κατάστασης από το savedInstanceState, αρχικοποίηση ViewModel και LiveData, ρύθμιση ακροατών κλικ και χειρονομιών. Η μέθοδος πρέπει να ολοκληρωθεί το συντομότερο δυνατό — οι χρονοβόρες λειτουργίες εδώ μπλοκάρουν την απόδοση του πρώτου καρέ, αυξάνοντας τον χρόνο εκκίνησης της εφαρμογής.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_profile)

    val userNameText: TextView = findViewById(R.id.user_name)
    val loadButton: Button = findViewById(R.id.load_button)

    if (savedInstanceState != null) {
        userNameText.text = savedInstanceState.getString("user_name")
    }

    loadButton.setOnClickListener {
        loadUserProfile()
    }
}

Αν το Activity δημιουργείται για πρώτη φορά, το savedInstanceState είναι null. Κατά την αναδημιουργία μετά από περιστροφή οθόνης, το Bundle περιέχει δεδομένα αποθηκευμένα στο onSaveInstanceState(). Ο έλεγχος για null είναι τυπική πρακτική για σωστή επαναφορά UI χωρίς απώλεια δεδομένων που εισήγαγε ο χρήστης.

onStart — εμφάνιση στην οθόνη

Το onStart() καλείται αμέσως μετά το onCreate() ή μετά το onRestart(), όταν το Activity γίνεται ορατό στον χρήστη. Σε αυτήν την κατάσταση, το Activity δεν βρίσκεται ακόμη στο προσκήνιο και δεν μπορεί να αλληλεπιδράσει με τον χρήστη, αλλά η διεπαφή χρήστη του είναι ήδη ορατή στην οθόνη. Για παράδειγμα, κατά την εκκίνηση της εφαρμογής, μεταξύ της κλήσης onStart και onResume, το σύστημα αποδίδει το πρώτο καρέ της διεπαφής.

Στη μέθοδο onStart συνήθως εκτελούνται οι ακόλουθες ενέργειες: έναρξη κινουμένων σχεδίων που πρέπει να λειτουργούν όσο το Activity είναι ορατό· σύνδεση BroadcastReceiver· σύνδεση με υπηρεσίες γεωτοποθεσίας και αισθητήρες· ενημέρωση δεδομένων από ViewModel ή Room. Εδώ επίσης γίνεται σύνδεση με Bound-υπηρεσίες μέσω bindService(), αν η εφαρμογή χρησιμοποιεί αρχιτεκτονική πελάτη-εξυπηρετητή εντός της διεργασίας.

override fun onStart() {
    super.onStart()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER,
        5000L,
        10f,
        locationListener
    )
}

override fun onStop() {
    super.onStop()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.removeUpdates(locationListener)
}

Σημαντικός κανόνας: οι πόροι που συνδέονται στο onStart πρέπει να απελευθερώνονται στο onStop. Αυτό εγγυάται ότι όταν το Activity δεν είναι ορατό στην οθόνη, δεν καταναλώνει μπαταρία και πόρους συστήματος. Το Google Play Store ελέγχει τις εφαρμογές για διαρροή LocationListener και άλλων υπηρεσιών συστήματος κατά την εποπτεία ενημερώσεων.

onResume — λήψη εστίασης

onResume() — η κατάσταση στην οποία το Activity βρίσκεται στο προσκήνιο και είναι έτοιμο για αλληλεπίδραση με τον χρήστη. Αυτή είναι η κατάσταση λειτουργίας της οθόνης: το σύστημα παραδίδει την εστίαση εισόδου στο Activity και όλα τα γεγονότα αφής, πληκτρολογίου και χειρονομιών κατευθύνονται σε αυτήν την οθόνη. Η μέθοδος onResume καλείται κάθε φορά που το Activity επιστρέφει στο προσκήνιο — μετά την ολοκλήρωση άλλου Activity, μετά το κλείσιμο παραθύρου διαλόγου, μετά το ξεκλείδωμα της συσκευής.

Στο onResume εκτελούνται: συνέχιση κινουμένων σχεδίων που είχαν τεθεί σε παύση στο onPause· άνοιγμα κάμερας και άλλων αποκλειστικών πόρων· καταχώριση ακροατών αισθητήρων (επιταχυνσιόμετρο, γυροσκόπιο)· έναρξη χρονομέτρων και χρονόμετρου για UI· ενημέρωση περιεχομένου οθόνης με τρέχοντα δεδομένα. Στο ζεύγος onResume / onPause εργαζόμαστε με πόρους που πρέπει να είναι ενεργοί μόνο όταν υπάρχει εστίαση — για παράδειγμα, συνεχής αναγνώριση ομιλίας ή καταγραφή βίντεο.

override fun onResume() {
    super.onResume()
    cameraHolder.openCamera()
    animator.resume()
    sensorManager.registerListener(
        stepCounter,
        sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER),
        SensorManager.SENSOR_DELAY_NORMAL
    )
}

override fun onPause() {
    super.onPause()
    cameraHolder.closeCamera()
    animator.pause()
    sensorManager.unregisterListener(stepCounter)
}

Η διαφορά μεταξύ onStart και onResume είναι σημαντική: το Activity μπορεί να είναι ορατό (onStart), αλλά όχι ενεργό (onResume) — για παράδειγμα, όταν εμφανίζεται ένα αναδυόμενο παράθυρο διαλόγου ή μια διαφανής οθόνη κλειδώματος πάνω του. Ακριβώς στο onResume, όχι στο onStart, πρέπει να ανοίγονται αποκλειστικοί πόροι που απαιτούν μονοπωλιακή πρόσβαση.

onPause — απώλεια εστίασης

Το onPause() καλείται όταν το Activity χάνει την εστίαση εισόδου, αλλά παραμένει εν μέρει ορατό. Τυπικά σενάρια: άνοιγμα παραθύρου διαλόγου, πάτημα κουμπιού «Πρόσφατες εφαρμογές», εισερχόμενη κλήση, πάτημα κουμπιού «Αρχική» (σε αυτήν την περίπτωση μετά το onPause θα ακολουθήσει το onStop). Η μέθοδος onPause είναι το τελευταίο αξιόπιστο μέρος για αποθήκευση δεδομένων που ο χρήστης δεν πρέπει να χάσει.

Στο onPause εκτελούνται: αποθήκευση προχείρων email και φορμών εισαγωγής σε Room ή SharedPreferences· διακοπή κινουμένων σχεδίων και αναπαραγωγής βίντεο· κλείσιμο κάμερας και απελευθέρωση μονοπωλιακών πόρων· ακύρωση δαπανηρών λειτουργιών που δεν είναι κρίσιμες για το παρασκήνιο. Η μέθοδος onPause πρέπει να ολοκληρωθεί σε λιγότερο από 100 χιλιοστά του δευτερολέπτου — το σύστημα μπλοκάρει τη μετάβαση στο επόμενο Activity έως ότου το onPause επιστρέψει τον έλεγχο και η υπέρβαση του ορίου οδηγεί σε ANR (Application Not Responding).

override fun onPause() {
    super.onPause()
    val editor = SharedPreferences.Manager ...
    editor.putString("draft_text", draftEditText.text.toString())
    editor.apply()
    videoView.pause()
    cameraHolder.release()
}

Σημαντικό: το onPause εκτελείται στο νήμα UI, επομένως οποιεσδήποτε λειτουργίες αποκλεισμού, όπως εγγραφή στη βάση δεδομένων μέσω Room με σύγχρονο ερώτημα, πρέπει να αντικατασταθούν με ασύγχρονες (coroutines) ή να εκτελεστούν σε νήμα παρασκηνίου. Χρησιμοποιήστε το apply() αντί για commit() για SharedPreferences — το apply γράφει δεδομένα ασύγχρονα και δεν μπλοκάρει το νήμα UI.

onStop — απόκρυψη από την οθόνη

Το onStop() καλείται όταν το Activity παύει να είναι ορατό στον χρήστη. Αυτό συμβαίνει στις ακόλουθες περιπτώσεις: το Activity καλύπτεται πλήρως από άλλο Activity· ο χρήστης πάτησε το κουμπί «Αρχική» ή μεταπήδησε σε άλλη εφαρμογή· το Activity τερματίζεται (θα κληθεί στη συνέχεια το onDestroy). Στην κατάσταση onStop, το Activity παραμένει στη μνήμη και διατηρεί όλα τα πεδία του — δεν έχει καταστραφεί, αλλά ούτε είναι ενεργό.

Στο onStop εκτελούνται: αποχώρηση από BroadcastReceiver που καταχωρήθηκαν στο onStart· αποσύνδεση από Bound-υπηρεσίες· απελευθέρωση LocationListener, SensorListener και άλλων ακροατών συστήματος· διακοπή μακροχρόνιων λειτουργιών παρασκηνίου που δεν χρειάζονται όταν η εφαρμογή είναι κρυφή· εγγραφή της τρέχουσας κατάστασης UI στο Bundle μέσω onSaveInstanceState(), αν αυτό δεν έγινε στο onPause.

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "Το Activity αναδημιουργείται λόγω διαμόρφωσης")
    }
}

Το σύστημα μπορεί να καταστρέψει το Activity στην κατάσταση onStop χωρίς να καλέσει το onDestroy σε περίπτωση έλλειψης μνήμης. Επομένως, όλα τα κρίσιμα δεδομένα πρέπει να αποθηκεύονται πριν από τη μετάβαση στο onStop. Η σημαία isChangingConfigurations() επιτρέπει να προσδιοριστεί αν η κλήση του onStop σχετίζεται με περιστροφή οθόνης — σε αυτήν την περίπτωση το Activity θα αναδημιουργηθεί, όχι να τερματιστεί.

onDestroy — καταστροφή Activity

onDestroy() — η τελευταία μέθοδος κύκλου ζωής, καλείται πριν από την πλήρη καταστροφή του Activity. Το σύστημα καλεί το onDestroy σε δύο περιπτώσεις: το Activity τερματίζεται με κλήση finish() ή ο χρήστης πατά το κουμπί «Πίσω»· το Activity καταστρέφεται από το σύστημα λόγω αλλαγής διαμόρφωσης (π.χ. περιστροφή οθόνης) και θα αναδημιουργηθεί. Η μέθοδος onDestroy επιτρέπει τον τελικό καθαρισμό πόρων: αποδέσμευση νημάτων και coroutines, κλείσιμο μόνιμα ανοιχτών cursors και sockets, απελευθέρωση εγγενούς μνήμης μέσω NDK.

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Το Activity τερματίζεται οριστικά")
    } else {
        Log.d("Lifecycle", "Το Activity θα αναδημιουργηθεί")
    }
}

Σημαντική σημείωση: το onDestroy δεν είναι εγγυημένο αν η διεργασία της εφαρμογής σκοτωθεί από το σύστημα (out-of-memory kill). Επομένως, δεν μπορείτε να βασιστείτε στο onDestroy για αποθήκευση δεδομένων — αυτή η εργασία επιλύεται στο onPause ή στο onStop. Η ιδιότητα isFinishing επιτρέπει τη διάκριση του τερματισμού του Activity μέσω finish() από την αναδημιουργία κατά την αλλαγή διαμόρφωσης.

onRestart — επιστροφή από σταματημένη κατάσταση

Το onRestart() καλείται πριν από το onStart(), όταν το Activity επιστρέφει από σταματημένη κατάσταση (onStop) πίσω στο προσκήνιο. Αυτό συμβαίνει όταν ο χρήστης ανοίγει ξανά την εφαρμογή από το μενού «Πρόσφατα» ή επιστρέφει στο Activity πατώντας «Πίσω» σε μια θυγατρική οθόνη. Η μέθοδος onRestart επιτρέπει την εκτέλεση λογικής διαφορετικής από το onCreate — για παράδειγμα, ενημέρωση δεδομένων που μπορεί να άλλαξαν ενώ το Activity ήταν κρυφό.

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Το Activity επανεκκινείται από τη στοίβα")
}

Τυπικό σενάριο: ο χρήστης άνοιξε την εφαρμογή, μεταπήδησε σε άλλη εργασία και επέστρεψε μία ώρα αργότερα. Στο onRestart, η εφαρμογή μπορεί να ελέγξει την επικαιρότητα των δεδομένων και, αν έχει περάσει πολύς χρόνος, να προσφέρει επαναφόρτωση περιεχομένου. Αυτό βελτιώνει την εμπειρία χρήστη και μειώνει την πιθανότητα εμφάνισης παρωχημένων πληροφοριών.

Περιστροφή οθόνης και αποθήκευση κατάστασης

Περιστροφή οθόνης — το πιο συνηθισμένο σενάριο αναδημιουργίας Activity. Από προεπιλογή, το Android καταστρέφει το τρέχον Activity και δημιουργεί ένα νέο σε κάθε αλλαγή προσανατολισμού. Αν δεν αποθηκευτεί η κατάσταση, ο χρήστης θα χάσει όλα τα δεδομένα που εισήγαγε. Γι' αυτό, το Android παρέχει δύο μηχανισμούς: onSaveInstanceState() για σειριοποιήσιμα δεδομένα και ViewModel για δεδομένα που επιβιώνουν από αλλαγές διαμόρφωσης.

onSaveInstanceState και onRestoreInstanceState

Το onSaveInstanceState() καλείται πριν από την καταστροφή του Activity για αποθήκευση προσωρινής κατάστασης. Τα αποθηκευμένα δεδομένα μεταφέρονται στο onCreate μέσω της παραμέτρου savedInstanceState και στη μέθοδο onRestoreInstanceState() που καλείται μετά το onStart. Το Bundle έχει περιορισμό μεγέθους — περίπου 500 KB, επομένως μεγάλοι όγκοι δεδομένων (π.χ., bitmaps) αποθηκεύονται μέσω ViewModel.

<!-- AndroidManifest.xml — καθήλωση προσανατολισμού -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

Η καθήλωση προσανατολισμού μέσω android:configChanges αποτρέπει την αναδημιουργία Activity, αλλά θεωρείται αντι-πρότυπο αν η εφαρμογή πρέπει να υποστηρίζει και τους δύο προσανατολισμούς. Η σύγχρονη σύσταση της Google — χρήση ViewModel σε συνδυασμό με onSaveInstanceState για δεδομένα που εισάγει ο χρήστης στο UI.

Κύκλος ζωής Fragment

Το Fragment έχει τον δικό του κύκλο ζωής, παρόμοιο με το Activity, αλλά με πρόσθετες μεθόδους: onAttach, onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach. Το Fragment υπάρχει πάντα μέσα σε ένα Activity και ο κύκλος ζωής του είναι δεμένος με τον κύκλο ζωής του Activity-περιέκτη. Αν το Activity καταστραφεί, το Fragment το ακολουθεί.

Η κύρια διαφορά: το Fragment διαχειρίζεται όχι μόνο την κατάσταση του στοιχείου, αλλά και την ιεραρχία View. Η μέθοδος onCreateView επιστρέφει το ριζικό View του fragment και η onDestroyView καταστρέφει αυτήν την ιεραρχία. Αυτό επιτρέπει στο Fragment να επιβιώσει από την αναδημιουργία Activity κατά την περιστροφή οθόνης: το Fragment διατηρείται και το View του αναδημιουργείται στο onCreateView.

class ProfileFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_profile, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val avatarImage: ImageView = view.findViewById(R.id.avatar_image)
        loadAvatar(avatarImage)
    }
}

Η κατανόηση της διαφοράς μεταξύ onCreate και onCreateView είναι κρίσιμης σημασίας: το onCreate καλείται μία φορά στη ζωή του Fragment (ακόμα και κατά την αναδημιουργία View), ενώ το onCreateView καλείται κάθε φορά που το Fragment δημιουργεί ή αναδημιουργεί την ιεραρχία View του. Η αρχικοποίηση δεδομένων γίνεται στο onCreate και η σύνδεση UI στο onViewCreated.

LifecycleObserver και Jetpack

LifecycleObserver — ένα στοιχείο της βιβλιοθήκης Android Jetpack που επιτρέπει την αντίδραση σε αλλαγές του κύκλου ζωής χωρίς παράκαμψη μεθόδων στο Activity ή το Fragment. Αντί να αντιγράφεται κώδικας σε κάθε μέθοδο κύκλου ζωής, ο προγραμματιστής δημιουργεί μια ξεχωριστή κλάση με σχολιασμούς @OnLifecycleEvent και τη μεταβιβάζει στο lifecycle.addObserver().

Το Jetpack παρέχει επίσης την κλάση LifecycleOwner — μια διεπαφή που υλοποιούν τα AppCompatActivity και Fragment. Κάθε αντικείμενο που υλοποιεί το LifecycleOwner μπορεί να διαχειρίζεται συνδρομές LiveData, coroutines μέσω lifecycleScope και εργασία WorkManager σε σχέση με τον κύκλο ζωής. Αυτός είναι ο ακρογωνιαίος λίθος της σύγχρονης αρχιτεκτονικής Android που βασίζεται σε MVVM και Jetpack.

class MyLocationObserver(private val context: Context) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        stopLocationUpdates()
    }
}

// Στο Activity:
lifecycle.addObserver(MyLocationObserver(this))

Η χρήση του DefaultLifecycleObserver απλοποιεί τη δοκιμή, μειώνει την αντιγραφή κώδικα και καθιστά τη λογική κύκλου ζωής επαναχρησιμοποιήσιμη μεταξύ διαφορετικών οθονών. Αυτή είναι η σύγχρονη αντικατάσταση της χειροκίνητης παράκαμψης onStart/onStop σε κάθε Activity. Στις εφαρμογές Android που αναπτύσσονται από την IT Sectr, εφαρμόζουμε το LifecycleObserver για γεωτοποθεσία, σάρωση Bluetooth και αναλυτικά στοιχεία — αυτό μειώνει τον όγκο boilerplate κώδικα κατά 30–40%.