Overview

The Activity lifecycle is a fundamental concept in Android development that defines how activities are created, started, resumed, paused, stopped, and destroyed. Understanding the lifecycle is crucial for managing resources, saving state, and providing a smooth user experience.

Activity Lifecycle States

public class MainActivity extends AppCompatActivity { private static final String TAG = "LifecycleDemo"; private TextView statusTextView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); statusTextView = findViewById(R.id.statusTextView); updateStatus("onCreate"); Log.d(TAG, "onCreate called"); // Initialize UI components initializeUI(); // Restore saved instance state if (savedInstanceState != null) { restoreState(savedInstanceState); } } private void initializeUI() { Button button = findViewById(R.id.myButton); button.setOnClickListener(v -> { // Handle button click startActivity(new Intent(this, SecondActivity.class)); }); } private void restoreState(Bundle savedInstanceState) { String savedText = savedInstanceState.getString("SAVED_TEXT"); if (savedText != null) { statusTextView.setText(savedText); } } @Override protected void onStart() { super.onStart(); updateStatus("onStart"); Log.d(TAG, "onStart called"); // Start services, register broadcast receivers registerReceivers(); } @Override protected void onResume() { super.onResume(); updateStatus("onResume"); Log.d(TAG, "onResume called"); // Resume animations, start camera preview, acquire resources startAnimations(); resumeAudioVideo(); } @Override protected void onPause() { super.onPause(); updateStatus("onPause"); Log.d(TAG, "onPause called"); // Pause animations, release camera, save temporary data pauseAnimations(); releaseCamera(); } @Override protected void onStop() { super.onStop(); updateStatus("onStop"); Log.d(TAG, "onStop called"); // Unregister receivers, stop location updates unregisterReceivers(); stopBackgroundTasks(); } @Override protected void onDestroy() { super.onDestroy(); updateStatus("onDestroy"); Log.d(TAG, "onDestroy called"); // Clean up resources, close database connections cleanupResources(); } @Override protected void onRestart() { super.onRestart(); updateStatus("onRestart"); Log.d(TAG, "onRestart called"); // Refresh data that might have changed while activity was stopped refreshData(); } private void updateStatus(String methodName) { String currentText = statusTextView.getText().toString(); statusTextView.setText(currentText + "\n" + methodName); } private void registerReceivers() { // Register broadcast receivers } private void unregisterReceivers() { // Unregister broadcast receivers } private void startAnimations() { // Start or resume animations } private void pauseAnimations() { // Pause animations } private void resumeAudioVideo() { // Resume audio/video playback } private void releaseCamera() { // Release camera resources } private void stopBackgroundTasks() { // Stop background tasks } private void cleanupResources() { // Clean up resources } private void refreshData() { // Refresh data from database or network } }

Saving and Restoring State

1. Instance State Saving

public class StatefulActivity extends AppCompatActivity { private static final String KEY_COUNTER = "counter"; private static final String KEY_USER_TEXT = "user_text"; private int counter = 0; private EditText userInput; private TextView counterText; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_stateful); userInput = findViewById(R.id.userInput); counterText = findViewById(R.id.counterText); Button incrementButton = findViewById(R.id.incrementButton); incrementButton.setOnClickListener(v -> { counter++; updateCounterDisplay(); }); // Restore state after configuration changes if (savedInstanceState != null) { restoreInstanceState(savedInstanceState); } } @Override protected void onSaveInstanceState(@NonNull Bundle outState) { super.onSaveInstanceState(outState); Log.d("StatefulActivity", "onSaveInstanceState called"); // Save important data outState.putInt(KEY_COUNTER, counter); outState.putString(KEY_USER_TEXT, userInput.getText().toString()); } @Override protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); Log.d("StatefulActivity", "onRestoreInstanceState called"); restoreInstanceState(savedInstanceState); } private void restoreInstanceState(Bundle savedInstanceState) { counter = savedInstanceState.getInt(KEY_COUNTER, 0); String savedText = savedInstanceState.getString(KEY_USER_TEXT, ""); userInput.setText(savedText); updateCounterDisplay(); } private void updateCounterDisplay() { counterText.setText("Counter: " + counter); } }

2. Persistent Data Storage

public class DataPersistenceActivity extends AppCompatActivity { private static final String PREF_NAME = "MyAppPrefs"; private static final String KEY_USER_NAME = "user_name"; private static final String KEY_LAST_ACTIVITY = "last_activity"; private SharedPreferences sharedPreferences; private EditText nameEditText; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_persistence); sharedPreferences = getSharedPreferences(PREF_NAME, MODE_PRIVATE); nameEditText = findViewById(R.id.nameEditText); loadSavedData(); Button saveButton = findViewById(R.id.saveButton); saveButton.setOnClickListener(v -> saveData()); } @Override protected void onPause() { super.onPause(); // Save data when activity goes to background saveData(); } private void loadSavedData() { String savedName = sharedPreferences.getString(KEY_USER_NAME, ""); String lastActivity = sharedPreferences.getString(KEY_LAST_ACTIVITY, ""); nameEditText.setText(savedName); if (!lastActivity.isEmpty()) { Toast.makeText(this, "Last activity: " + lastActivity, Toast.LENGTH_SHORT).show(); } } private void saveData() { String userName = nameEditText.getText().toString(); SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putString(KEY_USER_NAME, userName); editor.putString(KEY_LAST_ACTIVITY, "DataPersistenceActivity at " + System.currentTimeMillis()); editor.apply(); Toast.makeText(this, "Data saved!", Toast.LENGTH_SHORT).show(); } }

Practical Examples

Example 1: Camera Activity with Lifecycle Management

public class CameraActivity extends AppCompatActivity { private Camera camera; private SurfaceView cameraPreview; private boolean isCameraAvailable = false; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_camera); cameraPreview = findViewById(R.id.cameraPreview); Button captureButton = findViewById(R.id.captureButton); captureButton.setOnClickListener(v -> capturePhoto()); setupCameraPreview(); } @Override protected void onResume() { super.onResume(); openCamera(); } @Override protected void onPause() { super.onPause(); releaseCamera(); } @Override protected void onDestroy() { super.onDestroy(); // Ensure camera is released if (camera != null) { camera.release(); camera = null; } } private void setupCameraPreview() { // Setup surface view for camera preview SurfaceHolder holder = cameraPreview.getHolder(); holder.addCallback(new SurfaceHolder.Callback() { @Override public void surfaceCreated(SurfaceHolder holder) { // Surface is ready, but we'll open camera in onResume } @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { if (isCameraAvailable) { startPreview(); } } @Override public void surfaceDestroyed(SurfaceHolder holder) { stopPreview(); } }); } private void openCamera() { try { camera = Camera.open(); // Deprecated in API 21, but for demonstration isCameraAvailable = true; startPreview(); } catch (Exception e) { Log.e("CameraActivity", "Failed to open camera: " + e.getMessage()); isCameraAvailable = false; } } private void releaseCamera() { if (camera != null) { stopPreview(); camera.release(); camera = null; isCameraAvailable = false; } } private void startPreview() { if (camera == null || !cameraPreview.getHolder().getSurface().isValid()) { return; } try { camera.setPreviewDisplay(cameraPreview.getHolder()); camera.startPreview(); } catch (IOException e) { Log.e("CameraActivity", "Error starting camera preview: " + e.getMessage()); } } private void stopPreview() { if (camera != null) { camera.stopPreview(); } } private void capturePhoto() { if (!isCameraAvailable) { Toast.makeText(this, "Camera not available", Toast.LENGTH_SHORT).show(); return; } camera.takePicture(null, null, new Camera.PictureCallback() { @Override public void onPictureTaken(byte[] data, Camera camera) { // Save picture or process data savePicture(data); camera.startPreview(); // Restart preview after capture } }); } private void savePicture(byte[] data) { // Implementation to save picture to storage Toast.makeText(this, "Picture captured!", Toast.LENGTH_SHORT).show(); } }

Example 2: Music Player Activity

public class MusicPlayerActivity extends AppCompatActivity { private MediaPlayer mediaPlayer; private boolean isPrepared = false; private int currentPosition = 0; private static final String KEY_POSITION = "playback_position"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_music_player); initializePlayer(); setupControls(); if (savedInstanceState != null) { currentPosition = savedInstanceState.getInt(KEY_POSITION, 0); } } @Override protected void onStart() { super.onStart(); if (mediaPlayer != null && !mediaPlayer.isPlaying()) { mediaPlayer.seekTo(currentPosition); } } @Override protected void onResume() { super.onResume(); // Audio focus management would go here } @Override protected void onPause() { super.onPause(); if (mediaPlayer != null && mediaPlayer.isPlaying()) { mediaPlayer.pause(); currentPosition = mediaPlayer.getCurrentPosition(); } } @Override protected void onStop() { super.onStop(); // Save playback position to preferences for next session savePlaybackPosition(); } @Override protected void onDestroy() { super.onDestroy(); releasePlayer(); } @Override protected void onSaveInstanceState(@NonNull Bundle outState) { super.onSaveInstanceState(outState); if (mediaPlayer != null) { outState.putInt(KEY_POSITION, mediaPlayer.getCurrentPosition()); } } private void initializePlayer() { mediaPlayer = MediaPlayer.create(this, R.raw.sample_song); mediaPlayer.setOnPreparedListener(mp -> { isPrepared = true; mp.seekTo(currentPosition); }); mediaPlayer.setOnCompletionListener(mp -> { // Song completed, play next or reset resetPlayer(); }); } private void setupControls() { Button playButton = findViewById(R.id.playButton); Button pauseButton = findViewById(R.id.pauseButton); Button stopButton = findViewById(R.id.stopButton); playButton.setOnClickListener(v -> playMusic()); pauseButton.setOnClickListener(v -> pauseMusic()); stopButton.setOnClickListener(v -> stopMusic()); } private void playMusic() { if (mediaPlayer != null && !mediaPlayer.isPlaying()) { if (isPrepared) { mediaPlayer.start(); } else { mediaPlayer.prepareAsync(); } } } private void pauseMusic() { if (mediaPlayer != null && mediaPlayer.isPlaying()) { mediaPlayer.pause(); currentPosition = mediaPlayer.getCurrentPosition(); } } private void stopMusic() { if (mediaPlayer != null) { mediaPlayer.stop(); isPrepared = false; currentPosition = 0; } } private void resetPlayer() { if (mediaPlayer != null) { mediaPlayer.seekTo(0); currentPosition = 0; } } private void releasePlayer() { if (mediaPlayer != null) { mediaPlayer.release(); mediaPlayer = null; } } private void savePlaybackPosition() { SharedPreferences prefs = getSharedPreferences("MusicPlayer", MODE_PRIVATE); prefs.edit().putInt("last_position", currentPosition).apply(); } }

Example 3: Fragment-Activity Lifecycle Coordination

public class FragmentContainerActivity extends AppCompatActivity implements MyFragment.FragmentInteractionListener { private static final String TAG_FRAGMENT = "my_fragment"; private boolean isFragmentActive = false; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_fragment_container); // Add fragment if first creation if (savedInstanceState == null) { getSupportFragmentManager().beginTransaction() .add(R.id.fragment_container, new MyFragment(), TAG_FRAGMENT) .commit(); } } @Override protected void onResume() { super.onResume(); isFragmentActive = true; // Notify fragment that activity is resumed MyFragment fragment = (MyFragment) getSupportFragmentManager() .findFragmentByTag(TAG_FRAGMENT); if (fragment != null) { fragment.onActivityResumed(); } } @Override protected void onPause() { super.onPause(); isFragmentActive = false; // Notify fragment that activity is paused MyFragment fragment = (MyFragment) getSupportFragmentManager() .findFragmentByTag(TAG_FRAGMENT); if (fragment != null) { fragment.onActivityPaused(); } } // Fragment interaction callbacks @Override public void onFragmentButtonClicked(String message) { Toast.makeText(this, "Fragment says: " + message, Toast.LENGTH_SHORT).show(); } @Override public boolean isActivityActive() { return isFragmentActive; } } // Corresponding Fragment public class MyFragment extends Fragment { public interface FragmentInteractionListener { void onFragmentButtonClicked(String message); boolean isActivityActive(); } private FragmentInteractionListener listener; private TextView statusText; @Override public void onAttach(@NonNull Context context) { super.onAttach(context); if (context instanceof FragmentInteractionListener) { listener = (FragmentInteractionListener) context; } else { throw new RuntimeException(context.toString() + " must implement FragmentInteractionListener"); } } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_my, container, false); statusText = view.findViewById(R.id.statusText); Button actionButton = view.findViewById(R.id.actionButton); actionButton.setOnClickListener(v -> { if (listener != null) { listener.onFragmentButtonClicked("Button clicked from fragment!"); } }); return view; } @Override public void onResume() { super.onResume(); updateStatus("Fragment resumed"); } @Override public void onPause() { super.onPause(); updateStatus("Fragment paused"); } public void onActivityResumed() { updateStatus("Activity resumed - Fragment notified"); } public void onActivityPaused() { updateStatus("Activity paused - Fragment notified"); } private void updateStatus(String message) { if (statusText != null) { statusText.setText(message); } } @Override public void onDetach() { super.onDetach(); listener = null; } }

Advanced Lifecycle Scenarios

1. Handling Configuration Changes

public class ConfigChangeActivity extends AppCompatActivity { private static final String KEY_DATA = "important_data"; private static final String KEY_TIMESTAMP = "timestamp"; private String importantData; private long timestamp; private boolean isConfigChange = false; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_config_change); // Check if this is a configuration change if (savedInstanceState != null) { isConfigChange = true; restoreFromSavedState(savedInstanceState); } else { initializeNewData(); } setupUI(); logLifecycle("onCreate - Config change: " + isConfigChange); } @Override protected void onSaveInstanceState(@NonNull Bundle outState) { super.onSaveInstanceState(outState); logLifecycle("onSaveInstanceState"); // Save data that should survive configuration changes outState.putString(KEY_DATA, importantData); outState.putLong(KEY_TIMESTAMP, timestamp); } @Override protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); logLifecycle("onRestoreInstanceState"); restoreFromSavedState(savedInstanceState); } @Override public void onConfigurationChanged(@NonNull Configuration newConfig) { super.onConfigurationChanged(newConfig); logLifecycle("onConfigurationChanged"); // Handle configuration changes manually if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) { Toast.makeText(this, "Switched to Landscape", Toast.LENGTH_SHORT).show(); } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) { Toast.makeText(this, "Switched to Portrait", Toast.LENGTH_SHORT).show(); } } private void initializeNewData() { importantData = "Initial data created at " + System.currentTimeMillis(); timestamp = System.currentTimeMillis(); } private void restoreFromSavedState(Bundle savedInstanceState) { importantData = savedInstanceState.getString(KEY_DATA, "Default data"); timestamp = savedInstanceState.getLong(KEY_TIMESTAMP, System.currentTimeMillis()); } private void setupUI() { TextView dataView = findViewById(R.id.dataTextView); dataView.setText(importantData + "\nTimestamp: " + timestamp); Button refreshButton = findViewById(R.id.refreshButton); refreshButton.setOnClickListener(v -> refreshData()); } private void refreshData() { importantData = "Refreshed data at " + System.currentTimeMillis(); timestamp = System.currentTimeMillis(); setupUI(); // Refresh UI } private void logLifecycle(String method) { Log.d("ConfigChangeActivity", method); } }

2. Activity Result Handling

public class ResultHandlingActivity extends AppCompatActivity { private static final int REQUEST_SELECT_CONTACT = 1; private static final int REQUEST_TAKE_PHOTO = 2; private static final int REQUEST_PICK_DOCUMENT = 3; private TextView resultTextView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_result_handling); resultTextView = findViewById(R.id.resultTextView); setupButtons(); } private void setupButtons() { Button selectContactBtn = findViewById(R.id.selectContactButton); Button takePhotoBtn = findViewById(R.id.takePhotoButton); Button pickDocumentBtn = findViewById(R.id.pickDocumentButton); selectContactBtn.setOnClickListener(v -> selectContact()); takePhotoBtn.setOnClickListener(v -> takePhoto()); pickDocumentBtn.setOnClickListener(v -> pickDocument()); } private void selectContact() { Intent intent = new Intent(Intent.ACTION_PICK, ContactsContract.Contacts.CONTENT_URI); startActivityForResult(intent, REQUEST_SELECT_CONTACT); } private void takePhoto() { Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_TAKE_PHOTO); } else { Toast.makeText(this, "No camera app available", Toast.LENGTH_SHORT).show(); } } private void pickDocument() { Intent intent = new Intent(Intent.ACTION_GET_CONTENT); intent.setType("*/*"); intent.addCategory(Intent.CATEGORY_OPENABLE); try { startActivityForResult(intent, REQUEST_PICK_DOCUMENT); } catch (ActivityNotFoundException e) { Toast.makeText(this, "No file manager available", Toast.LENGTH_SHORT).show(); } } @Override protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) { super.onActivityResult(requestCode, resultCode, data); if (resultCode == RESULT_OK) { switch (requestCode) { case REQUEST_SELECT_CONTACT: handleContactSelection(data); break; case REQUEST_TAKE_PHOTO: handlePhotoCapture(data); break; case REQUEST_PICK_DOCUMENT: handleDocumentPick(data); break; } } else if (resultCode == RESULT_CANCELED) { updateResult("Operation cancelled by user"); } } private void handleContactSelection(Intent data) { if (data != null && data.getData() != null) { // Process contact URI updateResult("Contact selected: " + data.getData().toString()); } } private void handlePhotoCapture(Intent data) { if (data != null && data.getExtras() != null) { Bitmap imageBitmap = (Bitmap) data.getExtras().get("data"); if (imageBitmap != null) { updateResult("Photo captured: " + imageBitmap.getWidth() + "x" + imageBitmap.getHeight()); } } } private void handleDocumentPick(Intent data) { if (data != null && data.getData() != null) { updateResult("Document selected: " + data.getData().toString()); } } private void updateResult(String message) { resultTextView.setText("Last Result: " + message); Toast.makeText(this, message, Toast.LENGTH_SHORT).show(); } }

Best Practices

1. Lifecycle-Aware Components

public class LifecycleAwareActivity extends AppCompatActivity { private LocationManager locationManager; private NetworkMonitor networkMonitor; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_lifecycle_aware); // Initialize lifecycle-aware components locationManager = new LocationManager(this, getLifecycle()); networkMonitor = new NetworkMonitor(this, getLifecycle()); } } // Lifecycle-aware Location Manager public class LocationManager implements LifecycleObserver { private Context context; private LocationListener locationListener; public LocationManager(Context context, Lifecycle lifecycle) { this.context = context; lifecycle.addObserver(this); } @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) public void startLocationUpdates() { Log.d("LocationManager", "Starting location updates"); // Start location updates } @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) public void stopLocationUpdates() { Log.d("LocationManager", "Stopping location updates"); // Stop location updates } } // Lifecycle-aware Network Monitor public class NetworkMonitor implements LifecycleObserver { private Context context; private BroadcastReceiver networkReceiver; public NetworkMonitor(Context context, Lifecycle lifecycle) { this.context = context; lifecycle.addObserver(this); } @OnLifecycleEvent(Lifecycle.Event.ON_START) public void registerNetworkReceiver() { Log.d("NetworkMonitor", "Registering network receiver"); // Register network broadcast receiver } @OnLifecycleEvent(Lifecycle.Event.ON_STOP) public void unregisterNetworkReceiver() { Log.d("NetworkMonitor", "Unregistering network receiver"); // Unregister network broadcast receiver } }

2. Memory Management

public class MemoryAwareActivity extends AppCompatActivity { private Bitmap largeBitmap; private ArrayList<String> largeDataList; private static WeakReference<Context> contextWeakRef; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_memory_aware); contextWeakRef = new WeakReference<>(this); loadDataSafely(); } @Override protected void onDestroy() { super.onDestroy(); // Clean up resources to prevent memory leaks if (largeBitmap != null) { largeBitmap.recycle(); largeBitmap = null; } if (largeDataList != null) { largeDataList.clear(); largeDataList = null; } } @Override public void onLowMemory() { super.onLowMemory(); Log.w("MemoryAwareActivity", "Low memory warning received"); // Release non-critical resources releaseNonCriticalResources(); } @Override public void onTrimMemory(int level) { super.onTrimMemory(level); switch (level) { case TRIM_MEMORY_RUNNING_MODERATE: case TRIM_MEMORY_RUNNING_LOW: case TRIM_MEMORY_RUNNING_CRITICAL: // Release resources that can be quickly recreated releaseRecreatableResources(); break; case TRIM_MEMORY_UI_HIDDEN: // UI is no longer visible, release UI resources releaseUIResources(); break; } } private void loadDataSafely() { // Load data in background to avoid ANR new AsyncTask<Void, Void, Void>() { @Override protected Void doInBackground(Void... voids) { // Load data in background return null; } @Override protected void onPostExecute(Void aVoid) { // Update UI on main thread if (!isFinishing() && !isDestroyed()) { updateUIWithData(); } } }.execute(); } private void releaseNonCriticalResources() { // Release cache, temporary files, etc. } private void releaseRecreatableResources() { // Release resources that can be recreated } private void releaseUIResources() { // Release bitmaps, animations, etc. } private void updateUIWithData() { // Update UI with loaded data } }

Common Lifecycle Pitfalls and Solutions

public class LifecyclePitfallsActivity extends AppCompatActivity { // Pitfall 1: Starting async tasks without lifecycle consideration private void safeAsyncOperation() { if (isFinishing() || isDestroyed()) { return; // Don't start if activity is dying } new AsyncTask<Void, Void, String>() { @Override protected String doInBackground(Void... voids) { return performLongOperation(); } @Override protected void onPostExecute(String result) { // Check if activity is still alive if (!isFinishing() && !isDestroyed()) { updateUI(result); } } }.execute(); } // Pitfall 2: Holding context references private static class SafeHandler { private final WeakReference<Activity> activityRef; public SafeHandler(Activity activity) { this.activityRef = new WeakReference<>(activity); } public void doSomething() { Activity activity = activityRef.get(); if (activity != null && !activity.isFinishing()) { // Safe to use activity } } } // Pitfall 3: Not handling configuration changes properly @Override public Object onRetainCustomNonConfigurationInstance() { // Retain objects across configuration changes return new RetainedData("Important data"); } private void useRetainedData() { RetainedData data = (RetainedData) getLastCustomNonConfigurationInstance(); if (data != null) { // Use retained data } } private static class RetainedData { private String importantData; public RetainedData(String data) { this.importantData = data; } } private String performLongOperation() { return "Result"; } private void updateUI(String result) { // Update UI } }

Understanding and properly managing the Activity lifecycle is crucial for creating robust, efficient Android applications that provide a good user experience and properly manage system resources.