Chu kỳ hoạt động

Khi người dùng di chuyển qua, ra khỏi và quay lại ứng dụng của bạn, Activity thực thể trong quá trình chuyển đổi ứng dụng thông qua các trạng thái khác nhau trong vòng đời của chúng. Lớp Activity cung cấp một số lệnh gọi lại cho hoạt động biết khi một trạng thái thay đổi hoặc hệ thống đang tạo, dừng hoặc tiếp tục một hoạt động hoặc huỷ bỏ quá trình nơi hoạt động lưu trú.

Trong các phương thức gọi lại trong vòng đời, bạn có thể khai báo cách hoạt động của mình hoạt động khi người dùng rời khỏi và vào lại hoạt động. Ví dụ: nếu bạn đang ở khi tạo trình phát video trực tuyến, bạn có thể tạm dừng video và chấm dứt kết nối mạng khi người dùng chuyển sang một ứng dụng khác. Khi người dùng quay lại, bạn có thể kết nối lại với mạng và cho phép người dùng tiếp tục phát video từ cùng một vị trí.

Mỗi lệnh gọi lại cho phép bạn thực hiện công việc cụ thể phù hợp với thay đổi trạng thái nhất định. Làm đúng việc, đúng chỗ và xử lý chuyển đổi đúng cách giúp ứng dụng của bạn mạnh mẽ và hoạt động hiệu quả hơn. Ví dụ: việc triển khai tốt phương thức gọi lại trong vòng đời có thể giúp ứng dụng của bạn hãy tránh những điều sau:

• Sự cố nếu người dùng nhận được cuộc gọi điện thoại hoặc chuyển sang một cuộc gọi khác trong khi dùng ứng dụng.
• Tiêu thụ tài nguyên hệ thống có giá trị khi người dùng không hoạt động đang sử dụng nó.
• Mất tiến trình của người dùng nếu họ rời khỏi ứng dụng của bạn và quay lại việc đó sau này.
• Sự cố hoặc mất tiến trình của người dùng khi màn hình xoay giữa hướng ngang và dọc.

Tài liệu này giải thích chi tiết về vòng đời hoạt động. Tài liệu bắt đầu bằng cách mô tả mô hình vòng đời. Tiếp theo, phần này giải thích từng lệnh gọi lại: những gì xảy ra nội bộ khi thực thi và những việc bạn cần triển khai trong khi họ thực hiện các chiến dịch đó.

Sau đó, mô tả ngắn gọn về mối quan hệ giữa hoạt động trạng thái và lỗ hổng bảo mật của một quy trình bị hệ thống loại bỏ. Cuối cùng, tài liệu thảo luận một số chủ đề liên quan đến chuyển đổi giữa trạng thái hoạt động.

Để biết thông tin về cách xử lý vòng đời, bao gồm cả hướng dẫn về các phương pháp hay nhất, hãy xem Xử lý vòng đời bằng các thành phần nhận biết vòng đời và Lưu trạng thái giao diện người dùng. Tìm hiểu cách xây dựng một ứng dụng mạnh mẽ và đảm bảo chất lượng phát hành công khai bằng cách sử dụng các hoạt động trong kết hợp với các thành phần cấu trúc, hãy xem Hướng dẫn về cấu trúc ứng dụng.

Các khái niệm về vòng đời hoạt động

Để điều hướng quá trình chuyển đổi giữa các giai đoạn trong vòng đời hoạt động, Lớp Activity cung cấp một tập hợp cốt lõi gồm 6 lệnh gọi lại: onCreate(), onStart(), onResume(), onPause(), onStop() và onDestroy(). Hệ thống gọi mỗi lệnh gọi lại này khi hoạt động chuyển sang một trạng thái mới.

Hình 1 trình bày bản trình bày bằng hình ảnh của mô hình này.

Hình 1. Một kiểu đơn giản hình minh hoạ vòng đời hoạt động.

Khi người dùng bắt đầu rời khỏi hoạt động, hệ thống sẽ gọi các phương thức để tháo rời hoạt động đó. Trong một số trường hợp, hoạt động này chỉ là một phần bị tháo rời và vẫn nằm trong bộ nhớ, chẳng hạn như khi người dùng chuyển sang một ứng dụng khác. Trong những trường hợp này, hoạt động vẫn có thể quay lại nền trước.

Nếu người dùng quay lại hoạt động, sẽ tiếp tục từ nơi người dùng đã dừng lại. Với một vài ngoại lệ, các ứng dụng bị hạn chế từ bắt đầu các hoạt động khi chạy trong nền.

Khả năng hệ thống tắt một quy trình nhất định, cùng với các hoạt động trong đó, phụ thuộc vào trạng thái của hoạt động tại thời điểm đó. Để biết thêm thông tin về mối quan hệ giữa trạng thái và dễ bị tấn công khi bị đẩy ra khỏi bộ nhớ, hãy xem phần về trạng thái hoạt động và hiện tượng đẩy ra khỏi bộ nhớ.

Tuỳ thuộc vào mức độ phức tạp của hoạt động, bạn có thể không cần triển khai tất cả các phương thức vòng đời. Tuy nhiên, điều quan trọng là bạn và triển khai những phần tử khiến ứng dụng của bạn hoạt động theo cách mà người dùng mong đợi.

Phương thức gọi lại trong vòng đời

Phần này cung cấp thông tin khái niệm và thông tin triển khai liên quan đến phương thức gọi lại được sử dụng trong vòng đời hoạt động.

Có một số thao tác thuộc phương thức vòng đời hoạt động. Tuy nhiên, mã địa điểm triển khai các hành động của một thành phần phụ thuộc trong thay vì phương thức vòng đời hoạt động. Để đạt được điều này, bạn cần để làm cho thành phần phụ thuộc nhận biết được vòng đời. Để tìm hiểu cách tạo các thành phần phụ thuộc của bạn có khả năng nhận biết vòng đời, hãy xem Xử lý vòng đời bằng các thành phần nhận biết vòng đời.

onCreate()

Bạn phải triển khai lệnh gọi lại này. Lệnh gọi lại này sẽ kích hoạt khi hệ thống tạo của bạn. Khi tạo hoạt động, hoạt động sẽ chuyển sang trạng thái Created (Đã tạo). Trong onCreate() thực hiện logic khởi động ứng dụng cơ bản chỉ xảy ra một lần trong toàn bộ thời gian hoạt động.

Ví dụ: Việc triển khai onCreate() có thể liên kết dữ liệu với các danh sách, liên kết hoạt động với một ViewModel, và tạo thực thể cho một số biến phạm vi lớp. Phương thức này nhận giá trị tham số savedInstanceState, là Bundle đối tượng chứa trạng thái đã lưu trước đó của hoạt động. Nếu hoạt động có chưa từng tồn tại trước đó, giá trị của đối tượng Bundle là rỗng.

Nếu bạn có một thành phần nhận biết được vòng đời liên kết với vòng đời của hoạt động của bạn, nó sẽ nhận được ON_CREATE sự kiện. Phương thức được chú thích bằng @OnLifecycleEvent sẽ được gọi để nhận biết vòng đời thành phần có thể thực hiện bất kỳ mã thiết lập nào cần thiết cho trạng thái đã tạo.

Ví dụ sau về phương thức onCreate() cho thấy chế độ thiết lập cơ bản cho hoạt động, chẳng hạn như khai báo giao diện người dùng (được xác định trong tệp bố cục XML), xác định các biến thành phần và định cấu hình một số giao diện người dùng. Trong ví dụ này, tệp bố cục XML truyền hàm mã tài nguyên của tệp R.layout.main_activity để setContentView()

Kotlin

lateinit var textView: TextView

// Some transient state for the activity instance.
var gameState: String? = null

override fun onCreate(savedInstanceState: Bundle?) {
    // Call the superclass onCreate to complete the creation of
    // the activity, like the view hierarchy.
    super.onCreate(savedInstanceState)

    // Recover the instance state.
    gameState = savedInstanceState?.getString(GAME_STATE_KEY)

    // Set the user interface layout for this activity.
    // The layout is defined in the project res/layout/main_activity.xml file.
    setContentView(R.layout.main_activity)

    // Initialize member TextView so it is available later.
    textView = findViewById(R.id.text_view)
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). Some state is restored in onCreate(). Other state can optionally
// be restored here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
    textView.text = savedInstanceState?.getString(TEXT_VIEW_KEY)
}

// Invoked when the activity might be temporarily destroyed; save the instance state here.
override fun onSaveInstanceState(outState: Bundle?) {
    outState?.run {
        putString(GAME_STATE_KEY, gameState)
        putString(TEXT_VIEW_KEY, textView.text.toString())
    }
    // Call superclass to save any view hierarchy.
    super.onSaveInstanceState(outState)
}

Java

TextView textView;

// Some transient state for the activity instance.
String gameState;

@Override
public void onCreate(Bundle savedInstanceState) {
    // Call the superclass onCreate to complete the creation of
    // the activity, like the view hierarchy.
    super.onCreate(savedInstanceState);

    // Recover the instance state.
    if (savedInstanceState != null) {
        gameState = savedInstanceState.getString(GAME_STATE_KEY);
    }

    // Set the user interface layout for this activity.
    // The layout is defined in the project res/layout/main_activity.xml file.
    setContentView(R.layout.main_activity);

    // Initialize member TextView so it is available later.
    textView = (TextView) findViewById(R.id.text_view);
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). Some state is restored in onCreate(). Other state can optionally
// be restored here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
    textView.setText(savedInstanceState.getString(TEXT_VIEW_KEY));
}

// Invoked when the activity might be temporarily destroyed; save the instance state here.
@Override
public void onSaveInstanceState(Bundle outState) {
    outState.putString(GAME_STATE_KEY, gameState);
    outState.putString(TEXT_VIEW_KEY, textView.getText());

    // Call superclass to save any view hierarchy.
    super.onSaveInstanceState(outState);
}

Thay vì xác định tệp XML và truyền tệp đó đến setContentView(), bạn có thể tạo đối tượng View mới trong mã hoạt động và tạo một hệ phân cấp khung hiển thị bằng cách chèn đối tượng View mới vào một ViewGroup. Sau đó, bạn sử dụng bố cục đó bằng cách chuyển phương thức ViewGroup gốc thành setContentView(). Để biết thêm thông tin về cách tạo giao diện người dùng, hãy xem giao diện người dùng.

Hoạt động của bạn không nằm trong thư mục Đã tạo trạng thái. Sau khi phương thức onCreate() kết thúc quá trình thực thi, hoạt động sẽ chuyển sang trạng thái Started (Đã bắt đầu) và hệ thống sẽ gọi onStart() và onResume() một cách nhanh chóng kế thừa.

onStart()

Khi hoạt động chuyển sang trạng thái Started (Đã khởi động), hệ thống gọi onStart(). Lệnh gọi này làm cho hoạt động hiển thị với người dùng dưới dạng ứng dụng chuẩn bị cho hoạt động tiến vào nền trước và trở nên tương tác. Ví dụ: phương thức này là nơi mã duy trì giao diện người dùng đã được khởi chạy.

Khi hoạt động chuyển sang trạng thái Started (Đã khởi động), mọi thành phần nhận biết được vòng đời sẽ được liên kết vào vòng đời của hoạt động sẽ nhận được Sự kiện ON_START.

Phương thức onStart() hoàn tất một cách nhanh chóng và cũng giống như trạng thái "Đã tạo", hoạt động không ở trạng thái Started (Đã khởi động) Sau khi lệnh gọi lại này kết thúc, hoạt động sẽ nhập Trạng thái đã tiếp tục và hệ thống gọi onResume().

onResume()

Khi hoạt động chuyển sang trạng thái Đã tiếp tục, hoạt động sẽ xuất hiện ở nền trước và hệ thống sẽ gọi onResume() . Đây là trạng thái mà ứng dụng tương tác với người dùng. Ứng dụng sẽ ở trạng thái này cho đến khi có sự cố xảy ra đưa tiêu điểm ra khỏi ứng dụng, chẳng hạn như thiết bị nhận cuộc gọi điện thoại, người dùng di chuyển đến hoạt động khác hoặc màn hình thiết bị đang tắt.

Khi hoạt động chuyển sang trạng thái Đã tiếp tục, mọi thành phần nhận biết được vòng đời sẽ được liên kết vào vòng đời của hoạt động sẽ nhận được ON_RESUME sự kiện. Đây là nơi các thành phần trong vòng đời có thể kích hoạt mọi chức năng cần chạy trong khi thành phần đó xuất hiện và ở nền trước, chẳng hạn như khởi động máy ảnh bản xem trước.

Khi một sự kiện gián đoạn xảy ra, hoạt động này sẽ chuyển vào trạng thái Đã tạm dừng trạng thái và hệ thống sẽ gọi Gọi lại onPause().

Nếu hoạt động quay lại trạng thái Được tiếp tục từ trạng thái Đã tạm dừng, hệ thống một lần nữa gọi hàm onResume(). Vì lý do này, hãy triển khai onResume() để khởi chạy các thành phần mà bạn giải phóng trong onPause() và để thực hiện các thao tác khác các lượt khởi tạo phải xảy ra mỗi khi hoạt động nhập vào thẻ Tiếp tục trạng thái.

Dưới đây là ví dụ về một thành phần nhận biết vòng đời truy cập vào máy ảnh khi thành phần sẽ nhận được sự kiện ON_RESUME:

Kotlin

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun initializeCamera() {
        if (camera == null) {
            getCamera()
        }
    }
    ...
}

Java

public class CameraComponent implements LifecycleObserver {

    ...

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void initializeCamera() {
        if (camera == null) {
            getCamera();
        }
    }
    ...
}

Mã trước đó khởi chạy máy ảnh sau khi LifecycleObserver nhận được sự kiện ON_RESUME. Tuy nhiên, ở chế độ nhiều cửa sổ, hoạt động của bạn có thể hiển thị đầy đủ ngay cả khi ở trạng thái Đang tạm dừng. Ví dụ: khi ứng dụng ở chế độ nhiều cửa sổ và người dùng nhấn vào cửa sổ không chứa hoạt động của bạn, thì hoạt động sẽ chuyển sang trạng thái Paused (Đã tạm dừng).

Nếu bạn chỉ muốn máy ảnh hoạt động khi ứng dụng được Tiếp tục (hiển thị và hoạt động ở nền trước), rồi khởi chạy máy ảnh sau ON_RESUME sự kiện được minh hoạ trước đây. Nếu bạn muốn duy trì camera ở trạng thái hoạt động trong khi hoạt động bị tạm dừng nhưng hiển thị, chẳng hạn như ở chế độ nhiều cửa sổ, thì khởi chạy máy ảnh sau sự kiện ON_START.

Tuy nhiên, việc có máy ảnh hoạt động trong khi hoạt động của bạn bị Tạm dừng có thể khiến người khác không thể truy cập vào máy ảnh Đã tiếp tục ứng dụng ở chế độ nhiều cửa sổ. Đôi khi, bạn cần phải duy trì máy ảnh hoạt động trong khi hoạt động của bạn bị Tạm dừng, nhưng trên thực tế máy ảnh có thể làm giảm trải nghiệm tổng thể của người dùng.

Vì lý do này, hãy suy nghĩ kỹ về vị trí trong là phù hợp nhất để kiểm soát các tài nguyên hệ thống dùng chung trong bối cảnh của chế độ nhiều cửa sổ. Để tìm hiểu thêm về cách hỗ trợ chế độ nhiều cửa sổ hãy xem phần Hỗ trợ nhiều cửa sổ.

Bất kể bạn chọn sự kiện tích hợp nào để thực hiện hãy nhớ sử dụng vòng đời tương ứng để giải phóng tài nguyên. Nếu bạn khởi chạy điều gì đó sau sự kiện ON_START, huỷ bỏ hoặc chấm dứt sự kiện đó sau Sự kiện ON_STOP. Nếu bạn khởi chạy sau sự kiện ON_RESUME, phát hành sau sự kiện Sự kiện ON_PAUSE.

Đoạn mã trước đó đặt mã khởi chạy máy ảnh trong một thành phần nhận biết vòng đời. Thay vào đó, bạn có thể đặt trực tiếp mã này vào hoạt động phương thức gọi lại trong vòng đời, chẳng hạn như onStart() và onStop(), nhưng chúng tôi không khuyên bạn nên làm như vậy. Thêm logic này một thành phần độc lập, nhận biết vòng đời cho phép bạn sử dụng lại thành phần đó trên nhiều hoạt động mà không phải sao chép mã. Để tìm hiểu cách tạo một thành phần nhận biết vòng đời, hãy xem Xử lý vòng đời bằng các thành phần nhận biết vòng đời.

onPause()

Hệ thống gọi phương thức này là dấu hiệu đầu tiên cho biết người dùng đang rời đi hoạt động của bạn, mặc dù điều này không phải lúc nào cũng có nghĩa là hoạt động đó cũng bị huỷ bỏ. Nó cho biết hoạt động không còn ở nền trước nhưng vẫn hoạt động vẫn hiển thị nếu người dùng đang ở chế độ nhiều cửa sổ. Có một số lý do khiến một hoạt động có thể nhập trạng thái này:

• Một sự kiện làm gián đoạn quá trình thực thi ứng dụng, như mô tả trong phần về lệnh gọi lại onResume(), tạm dừng hoạt động hiện tại. Đây là trường hợp phổ biến nhất trường hợp.
• Ở chế độ nhiều cửa sổ, chỉ một ứng dụng có tiêu điểm bất cứ lúc nào và hệ thống sẽ tạm dừng tất cả các ứng dụng khác.
• Việc mở một hoạt động mới, bán trong suốt, chẳng hạn như hộp thoại, tạm dừng hoạt động mà nó thực hiện. Miễn là hoạt động chỉ hiện một phần nhưng không được đặt tiêu điểm vẫn bị tạm dừng.

Khi một hoạt động chuyển sang trạng thái "Đang tạm dừng", mọi thành phần nhận biết được vòng đời sẽ được liên kết vào vòng đời của hoạt động sẽ nhận được Sự kiện ON_PAUSE. Đây là nơi các thành phần trong vòng đời có thể dừng mọi chức năng không cần chạy khi thành phần không chạy ở nền trước (chẳng hạn như dừng máy ảnh) bản xem trước.

Sử dụng phương thức onPause() để tạm dừng hoặc điều chỉnh các hoạt động không thể tiếp tục hoặc có thể tiếp tục một cách kiểm duyệt, khi Activity ở trạng thái Bị tạm dừng và bạn dự kiến sẽ sớm tiếp tục.

Bạn cũng có thể sử dụng phương thức onPause() để giải phóng tài nguyên hệ thống, xử lý tài nguyên cho cảm biến (như GPS) hoặc bất kỳ tài nguyên nào ảnh hưởng đến thời lượng pin trong khi hoạt động của bạn bị Tạm dừng và người dùng không cần chúng.

Tuy nhiên, như đã đề cập trong phần về onResume(), việc tạm dừng hoạt động vẫn có thể hiển thị đầy đủ nếu ứng dụng ở chế độ nhiều cửa sổ. Hãy cân nhắc sử dụng onStop() thay vì onPause() để huỷ bỏ hoặc điều chỉnh hoàn toàn Các tài nguyên và hoạt động liên quan đến giao diện người dùng để hỗ trợ tốt hơn cho chế độ nhiều cửa sổ.

Ví dụ sau về LifecycleObserver phản ứng với sự kiện ON_PAUSE là phản ứng với sự kiện trước đó Ví dụ về sự kiện ON_RESUME, phát hành máy ảnh khởi chạy sau sự kiện ON_RESUME sẽ nhận được:

Kotlin

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun releaseCamera() {
        camera?.release()
        camera = null
    }
    ...
}

Java

public class JavaCameraComponent implements LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void releaseCamera() {
        if (camera != null) {
            camera.release();
            camera = null;
        }
    }
    ...
}

Ví dụ này đặt mã phát hành máy ảnh sau LifecycleObserver nhận được sự kiện ON_PAUSE.

Quá trình thực thi onPause() rất ngắn và không nhất thiết phải có đủ thời gian để thực hiện thao tác lưu. Để làm việc này lý do là không sử dụng onPause() để lưu ứng dụng hoặc người dùng dữ liệu, thực hiện lệnh gọi mạng hoặc thực thi các giao dịch cơ sở dữ liệu. Công việc đó có thể không hoàn tất trước khi phương thức này hoàn tất.

Thay vào đó, hãy thực hiện các thao tác tắt đối với các tệp tải nặng trong onStop(). Thông tin khác về các thao tác phù hợp cần thực hiện trong khoảng thời gian onStop(), xem phần tiếp theo. Để biết thêm thông tin về cách lưu hãy xem phần lưu và khôi phục trạng thái.

Hoàn thành phương thức onPause() không có nghĩa là hoạt động rời khỏi trạng thái Paused (Đã tạm dừng). Thay vào đó, hoạt động duy trì trạng thái này cho đến khi hoạt động tiếp tục hoặc hoàn tất không hiển thị với người dùng. Nếu hoạt động tiếp tục, hệ thống lại gọi lệnh gọi lại onResume().

Nếu hoạt động quay trở lại từ trạng thái Tạm dừng sang trạng thái Tiếp tục, hệ thống liên tục thực thể Activity cư trú trong bộ nhớ, gọi lại lần đó khi hệ thống gọi onResume(). Trong trường hợp này, bạn không cần khởi động lại các thành phần được tạo trong bất kỳ phương thức gọi lại dẫn đến trạng thái Đã tiếp tục. Nếu hoạt động trở thành hoàn toàn ẩn, hệ thống gọi onStop().

onStop()

Khi người dùng không còn nhìn thấy hoạt động của bạn, hoạt động này sẽ được nhập vào Trạng thái Đã dừng và hệ thống gọi Gọi lại onStop(). Điều này có thể xảy ra khi một hoạt động mới khởi chạy bao phủ toàn bộ màn hình. Chiến lược phát hành đĩa đơn hệ thống cũng gọi onStop() khi hoạt động chạy xong và sắp kết thúc.

Khi hoạt động chuyển sang trạng thái Đã dừng, mọi thành phần nhận biết được vòng đời sẽ được liên kết vào vòng đời của hoạt động sẽ nhận được Sự kiện ON_STOP. Đây là nơi các thành phần trong vòng đời có thể dừng mọi chức năng không cần chạy trong khi thành phần không hiển thị trên màn hình.

Trong phương thức onStop(), hãy thả hoặc điều chỉnh không cần thiết trong khi ứng dụng không hiển thị với người dùng. Ví dụ: ứng dụng của bạn có thể tạm dừng hoạt ảnh hoặc chuyển từ cập nhật vị trí chi tiết sang cập nhật vị trí tương đối. Sử dụng onStop() thay vì onPause() có nghĩa là công việc liên quan đến giao diện người dùng vẫn tiếp tục, ngay cả khi người dùng đang xem hoạt động của bạn ở chế độ nhiều cửa sổ .

Ngoài ra, hãy dùng onStop() để thực hiện thao tác tắt tương đối tiêu tốn nhiều CPU. Ví dụ: nếu bạn không thể tìm thấy thời điểm tốt hơn để lưu thông tin vào cơ sở dữ liệu, bạn có thể làm như vậy trong onStop(). Chiến lược phát hành đĩa đơn ví dụ sau đây cho thấy cách triển khai onStop() lưu nội dung của tạo bản nháp ghi chú để lưu trữ liên tục:

Kotlin

override fun onStop() {
    // Call the superclass method first.
    super.onStop()

    // Save the note's current draft, because the activity is stopping
    // and we want to be sure the current note progress isn't lost.
    val values = ContentValues().apply {
        put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText())
        put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle())
    }

    // Do this update in background on an AsyncQueryHandler or equivalent.
    asyncQueryHandler.startUpdate(
            token,     // int token to correlate calls
            null,      // cookie, not used here
            uri,       // The URI for the note to update.
            values,    // The map of column names and new values to apply to them.
            null,      // No SELECT criteria are used.
            null       // No WHERE columns are used.
    )
}

Java

@Override
protected void onStop() {
    // Call the superclass method first.
    super.onStop();

    // Save the note's current draft, because the activity is stopping
    // and we want to be sure the current note progress isn't lost.
    ContentValues values = new ContentValues();
    values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText());
    values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle());

    // Do this update in background on an AsyncQueryHandler or equivalent.
    asyncQueryHandler.startUpdate (
            mToken,  // int token to correlate calls
            null,    // cookie, not used here
            uri,    // The URI for the note to update.
            values,  // The map of column names and new values to apply to them.
            null,    // No SELECT criteria are used.
            null     // No WHERE columns are used.
    );
}

Mã mẫu ở trên sử dụng trực tiếp SQLite. Tuy nhiên, bạn nên dùng Room, một thư viện cố định cung cấp tầng trừu tượng qua SQLite. Để tìm hiểu tìm hiểu thêm về lợi ích của việc sử dụng Room và cách triển khai Room trong ứng dụng, xem Thư viện lưu trữ Room của chúng tôi.

Khi hoạt động của bạn chuyển sang trạng thái Đã dừng, Activity đối tượng thường trú trong bộ nhớ: nó duy trì tất cả trạng thái và thành phần nhưng không được đính kèm vào trình quản lý cửa sổ. Khi hoạt động tiếp tục, nó sẽ nhớ lại thông tin này.

Bạn không cần khởi động lại các thành phần được tạo trong bất kỳ phương thức gọi lại nào dẫn đến trạng thái Đã tiếp tục. Hệ thống cũng theo dõi xu hướng trạng thái cho từng đối tượng View trong bố cục, vì vậy nếu giá trị người dùng nhập văn bản vào một tiện ích EditText, nội dung được giữ lại, do đó bạn không cần lưu và khôi phục nội dung đó.

Lưu ý: Sau khi dừng hoạt động, hệ thống có thể huỷ bỏ quá trình chứa hoạt động nếu hệ thống cần khôi phục bộ nhớ. Ngay cả khi hệ thống huỷ bỏ quá trình trong khi hoạt động là đã dừng, hệ thống vẫn giữ nguyên trạng thái của View các đối tượng (chẳng hạn như văn bản trong một tiện ích EditText) trong một Bundle — một blob của các cặp khoá-giá trị và khôi phục chúng nếu người dùng quay lại hoạt động. Cho để biết thêm thông tin về việc khôi phục một hoạt động mà người dùng quay lại, hãy xem giới thiệu về lưu và khôi phục trạng thái.

Từ trạng thái Đã dừng, hoạt động quay lại để tương tác với hoặc hoạt động đã chạy xong và biến mất. Nếu hoạt động đến quay lại, hệ thống sẽ gọi onRestart(). Nếu Activity đã chạy xong, hệ thống sẽ gọi onDestroy()

onDestroy()

onDestroy() được gọi trước bị huỷ bỏ. Hệ thống gọi lệnh gọi lại này vì một trong hai lý do:

1. Hoạt động đang kết thúc do người dùng đóng hoàn toàn hoạt động hoặc do finish() đang được được gọi đối với hoạt động.
2. Hệ thống đang tạm thời huỷ hoạt động do cấu hình thay đổi, chẳng hạn như xoay thiết bị hoặc vào chế độ nhiều cửa sổ.

Khi hoạt động chuyển sang trạng thái bị huỷ bỏ, mọi thành phần nhận biết được vòng đời sẽ được liên kết vào vòng đời của hoạt động sẽ nhận được Sự kiện ON_DESTROY. Đây là nơi các thành phần trong vòng đời có thể dọn dẹp mọi thứ chúng cần thiết trước khi Activity đã bị huỷ.

Thay vì đặt logic vào Activity để xác định lý do khiến mã đó bị huỷ, sử dụng đối tượng ViewModel để chứa dữ liệu khung hiển thị phù hợp cho Activity của bạn. Nếu Activity được tạo lại do thay đổi về cấu hình, ViewModel không phải làm gì cả, vì nó sẽ được giữ nguyên và được cấp cho thực thể Activity tiếp theo.

Nếu Activity không được tạo lại, thì ViewModel có giá trị Phương thức onCleared() được gọi, trong đó ứng dụng có thể dọn dẹp mọi dữ liệu cần thiết trước khi bị huỷ. Bạn có thể phân biệt giữa hai trường hợp này với Phương thức isFinishing().

Nếu hoạt động đang kết thúc, onDestroy() là lệnh gọi lại cuối cùng trong vòng đời hoạt động nhận được. Nếu onDestroy() được gọi do cấu hình thì hệ thống sẽ ngay lập tức tạo một thực thể hoạt động mới rồi gọi onCreate() trên thực thể mới đó trong cấu hình mới.

Lệnh gọi lại onDestroy() giải phóng tất cả các tài nguyên chưa được phát hành trước đó lệnh gọi lại, chẳng hạn như onStop().

Trạng thái hoạt động và đẩy ra khỏi bộ nhớ

Hệ thống sẽ tắt các quy trình khi cần giải phóng RAM. Khả năng của hệ thống việc dừng một quy trình nhất định phụ thuộc vào trạng thái của quy trình tại thời điểm đó. Trạng thái xử lý, phụ thuộc vào trạng thái của hoạt động đang chạy trong quy trình. Bảng 1 cho thấy mối tương quan giữa trạng thái quá trình, hoạt động và khả năng hệ thống tắt quá trình này. Bảng này chỉ áp dụng nếu một quy trình không chạy các loại thành phần ứng dụng.

Khả năng bị giết	Trạng thái xử lý	Trạng thái hoạt động cuối cùng
Thấp nhất	Nền trước (đang hoặc sắp được lấy tiêu điểm)	Đã tiếp tục
Thấp	Hiển thị (không có tiêu điểm)	Đã bắt đầu/Tạm dừng
Cao hơn	Nền (ẩn)	Stopped (Đã dừng)
Cao nhất	Trống	Đã huỷ bỏ

Bảng 1. Mối quan hệ giữa vòng đời quy trình và trạng thái hoạt động.

Hệ thống không bao giờ trực tiếp tắt một hoạt động để giải phóng bộ nhớ. Thay vào đó, tắt quy trình mà hoạt động chạy trong đó, không chỉ huỷ bỏ hoạt động mà còn mọi thứ khác đang chạy trong quá trình này. Để tìm hiểu cách duy trì và khôi phục trạng thái giao diện người dùng của hoạt động khi quá trình bị buộc tắt do hệ thống gây ra xảy ra, hãy xem phần lưu và khôi phục trạng thái.

Người dùng cũng có thể dừng một quá trình bằng cách sử dụng Trình quản lý ứng dụng, trong phần Cài đặt, để tắt ứng dụng tương ứng.

Để biết thêm thông tin về các quy trình, hãy xem Quy trình và luồng tổng quan.

Lưu và khôi phục trạng thái giao diện người dùng tạm thời

Người dùng muốn trạng thái giao diện người dùng của một hoạt động vẫn giữ nguyên trong một thay đổi cấu hình, chẳng hạn như xoay hoặc chuyển sang chế độ nhiều cửa sổ. Tuy nhiên, theo mặc định, hệ thống sẽ huỷ hoạt động khi cấu hình như vậy thay đổi xảy ra, xoá sạch mọi trạng thái giao diện người dùng đã lưu trong thực thể của hoạt động.

Tương tự, người dùng muốn trạng thái giao diện người dùng vẫn giữ nguyên nếu họ tạm thời chuyển khỏi ứng dụng của bạn sang một ứng dụng khác rồi quay lại ứng dụng đó sau. Tuy nhiên, hệ thống có thể huỷ bỏ quy trình của ứng dụng trong khi và hoạt động của bạn bị dừng lại.

Khi các quy tắc ràng buộc của hệ thống huỷ bỏ hoạt động này, hãy duy trì trạng thái giao diện người dùng tạm thời của người dùng bằng cách sử dụng kết hợp các ViewModel! onSaveInstanceState(), và/hoặc bộ nhớ cục bộ. Để tìm hiểu thêm về kỳ vọng của người dùng so với hệ thống và cách tốt nhất để duy trì dữ liệu trạng thái giao diện người dùng phức tạp trên hoạt động do hệ thống gây ra và trường hợp bị buộc tắt, hãy xem Lưu trạng thái giao diện người dùng.

Phần này trình bày trạng thái của thực thể và cách triển khai Phương thức onSaveInstance(), là một lệnh gọi lại trên chính hoạt động đó. Nếu Dữ liệu giao diện người dùng gọn nhẹ, bạn có thể chỉ sử dụng onSaveInstance() để duy trì giao diện người dùng trạng thái trên cả các thay đổi về cấu hình và sự kiện bị buộc tắt do hệ thống gây ra. Tuy nhiên, vì onSaveInstance() làm phát sinh chi phí chuyển đổi tuần tự/huỷ chuyển đổi tuần tự, theo trong hầu hết các trường hợp, bạn sử dụng cả ViewModel và onSaveInstance(), vì được vẽ đường viền trong Lưu trạng thái giao diện người dùng.

Lưu ý: Để tìm hiểu thêm về những thay đổi về cấu hình, cách hạn chế Hoạt động tạo lại nếu cần và cách phản ứng với những thay đổi về cấu hình đó từ View system và Jetpack Compose, hãy tham khảo Trang Xử lý các thay đổi về cấu hình.

Trạng thái của thực thể

Có một vài trường hợp trong đó hoạt động của bạn bị huỷ bỏ do ứng dụng thông thường chẳng hạn như khi người dùng nhấn nút Quay lại hoặc hoạt động của bạn báo hiệu sự phá huỷ của chính nó bằng cách gọi hàm finish() .

Khi hoạt động của bạn bị huỷ do người dùng nhấn Quay lại hoặc hoạt động tự kết thúc, cả khái niệm của cả hệ thống và người dùng về thực thể Activity đó đã biến mất vĩnh viễn. Trong các trong trường hợp cụ thể, kỳ vọng của người dùng khớp với hành vi của hệ thống và bạn không không cần làm gì thêm.

Tuy nhiên, nếu hệ thống huỷ bỏ hoạt động đó do những hạn chế của hệ thống (chẳng hạn như thay đổi cấu hình hoặc áp lực bộ nhớ), thì mặc dù sự cố thực tế Activity thực thể đã biến mất, hệ thống sẽ ghi nhớ rằng thực thể đó đã tồn tại. Nếu người dùng cố gắng quay lại hoạt động, hệ thống sẽ tạo một thực thể mới của hoạt động đó thông qua một tập dữ liệu đã lưu mô tả trạng thái của hoạt động thời điểm tài liệu bị huỷ.

Dữ liệu đã lưu mà hệ thống sử dụng để khôi phục trạng thái trước đó được gọi là trạng thái thực thể. Đây là bộ sưu tập cặp khoá-giá trị được lưu trữ trong đối tượng Bundle. Theo mặc định, hệ thống sử dụng trạng thái thực thể Bundle để lưu thông tin về từng đối tượng View trong bố cục hoạt động, chẳng hạn như giá trị văn bản được nhập vào Tiện ích EditText.

Vì vậy, nếu thực thể hoạt động của bạn bị huỷ và tạo lại, trạng thái của bố cục là đã khôi phục về trạng thái trước đó mà bạn không cần phải lập trình. Tuy nhiên, có thể có nhiều thông tin trạng thái hơn mà bạn muốn khôi phục, chẳng hạn như các biến thành phần theo dõi tiến trình của người dùng trong hoạt động.

Lưu ý: Để hệ thống Android khôi phục lại trạng thái của các khung hiển thị trong hoạt động của bạn, mỗi khung hiển thị phải có một mã nhận dạng duy nhất do thuộc tính android:id.

Đối tượng Bundle không thích hợp để duy trì hơn một lượng dữ liệu không đáng kể vì yêu cầu chuyển đổi tuần tự trên luồng chính và tốn bộ nhớ tiến trình của hệ thống. Để duy trì nhiều hơn một lượng rất nhỏ dữ liệu, thực hiện phương pháp kết hợp để bảo toàn dữ liệu, sử dụng cục bộ ổn định bộ nhớ, phương thức onSaveInstanceState() và Lớp ViewModel, như được nêu trong Lưu trạng thái giao diện người dùng.

Lưu trạng thái giao diện người dùng đơn giản và gọn nhẹ bằng onSaveInstanceState()

Khi hoạt động của bạn bắt đầu dừng, hệ thống sẽ gọi onSaveInstanceState() để hoạt động của bạn có thể lưu thông tin trạng thái vào trạng thái thực thể gói. Phương thức triển khai mặc định của phương thức này sẽ lưu tạm thời thông tin về trạng thái hệ phân cấp khung hiển thị của hoạt động, chẳng hạn như văn bản trong tiện ích EditText hoặc vị trí cuộn của Tiện ích ListView.

Để lưu thông tin bổ sung về trạng thái thực thể cho hoạt động của bạn, hãy ghi đè onSaveInstanceState() rồi thêm cặp khoá-giá trị vào đối tượng Bundle đã lưu trong trường hợp hoạt động của bạn bị huỷ đột ngột. Khi bạn ghi đè onSaveInstanceState(), bạn cần gọi phương thức triển khai lớp cấp cao nếu bạn muốn phương thức triển khai mặc định lưu trạng thái của hệ phân cấp khung hiển thị. Lệnh này được minh hoạ trong ví dụ sau:

Kotlin

override fun onSaveInstanceState(outState: Bundle?) {
    // Save the user's current game state.
    outState?.run {
        putInt(STATE_SCORE, currentScore)
        putInt(STATE_LEVEL, currentLevel)
    }

    // Always call the superclass so it can save the view hierarchy state.
    super.onSaveInstanceState(outState)
}

companion object {
    val STATE_SCORE = "playerScore"
    val STATE_LEVEL = "playerLevel"
}

Java

static final String STATE_SCORE = "playerScore";
static final String STATE_LEVEL = "playerLevel";
// ...


@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the user's current game state.
    savedInstanceState.putInt(STATE_SCORE, currentScore);
    savedInstanceState.putInt(STATE_LEVEL, currentLevel);

    // Always call the superclass so it can save the view hierarchy state.
    super.onSaveInstanceState(savedInstanceState);
}

Lưu ý: onSaveInstanceState() không được gọi khi người dùng đóng hoạt động một cách rõ ràng hoặc trong các trường hợp khác khi finish() sẽ được gọi.

Để lưu dữ liệu cố định, chẳng hạn như lựa chọn ưu tiên của người dùng hoặc dữ liệu cho một cơ sở dữ liệu, nắm bắt cơ hội thích hợp khi hoạt động của bạn diễn ra ở nền trước. Nếu không có cơ hội như vậy, hãy lưu dữ liệu ổn định trong Phương thức onStop().

Khôi phục trạng thái giao diện người dùng của hoạt động bằng cách sử dụng trạng thái của thực thể đã lưu

Khi hoạt động được tạo lại sau khi hoạt động đã bị huỷ trước đó, bạn có thể khôi phục trạng thái của thực thể đã lưu từ Bundle mà chuyển sang hoạt động của bạn. Cả hai thuộc tính onCreate() và onRestoreInstanceState() phương thức gọi lại nhận được cùng một Bundle chứa thông tin về trạng thái thực thể.

Vì phương thức onCreate() là được gọi là liệu hệ thống có đang tạo một phiên bản mới của hoạt động hoặc tạo lại một trạng thái trước đó, bạn cần kiểm tra xem trạng thái Bundle rỗng trước khi bạn thử đọc. Nếu giá trị này là rỗng, thì hệ thống là tạo một thực thể mới của hoạt động thay vì khôi phục một thực thể mục trước đó đã bị huỷ.

Đoạn mã sau đây cho biết cách bạn có thể khôi phục một số dữ liệu trạng thái trong onCreate():

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState) // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance.
    if (savedInstanceState != null) {
        with(savedInstanceState) {
            // Restore value of members from saved state.
            currentScore = getInt(STATE_SCORE)
            currentLevel = getInt(STATE_LEVEL)
        }
    } else {
        // Probably initialize members with default values for a new instance.
    }
    // ...
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance.
    if (savedInstanceState != null) {
        // Restore value of members from saved state.
        currentScore = savedInstanceState.getInt(STATE_SCORE);
        currentLevel = savedInstanceState.getInt(STATE_LEVEL);
    } else {
        // Probably initialize members with default values for a new instance.
    }
    // ...
}

Thay vì khôi phục trạng thái trong onCreate(), bạn có thể chọn triển khai onRestoreInstanceState() mà hệ thống gọi sau onStart(). Hệ thống gọi onRestoreInstanceState() chỉ khi có một trạng thái đã lưu cần khôi phục, vì vậy bạn không cần kiểm tra xem Bundle có rỗng hay không.

Kotlin

override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
    // Always call the superclass so it can restore the view hierarchy.
    super.onRestoreInstanceState(savedInstanceState)

    // Restore state members from saved instance.
    savedInstanceState?.run {
        currentScore = getInt(STATE_SCORE)
        currentLevel = getInt(STATE_LEVEL)
    }
}

Java

public void onRestoreInstanceState(Bundle savedInstanceState) {
    // Always call the superclass so it can restore the view hierarchy.
    super.onRestoreInstanceState(savedInstanceState);

    // Restore state members from saved instance.
    currentScore = savedInstanceState.getInt(STATE_SCORE);
    currentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

Thận trọng: Luôn gọi quá trình triển khai lớp cấp cao của onRestoreInstanceState() do đó, cách triển khai mặc định có thể khôi phục trạng thái của hệ phân cấp khung hiển thị.

Di chuyển giữa các hoạt động

Một ứng dụng có thể truy cập và thoát khỏi một hoạt động, có thể nhiều lần, trong vòng đời của ứng dụng, chẳng hạn như khi người dùng nhấn vào nút Quay lại của thiết bị hoặc hoạt động khởi chạy một hoạt động khác.

Phần này bao gồm những chủ đề mà bạn cần biết để triển khai quá trình chuyển đổi hoạt động thành công. Các chủ đề này bao gồm việc bắt đầu một hoạt động từ một hoạt động khác, lưu hoạt động trạng thái và khôi phục trạng thái hoạt động.

Bắt đầu một hoạt động từ một hoạt động khác

Một hoạt động thường cần phải bắt đầu một hoạt động khác vào một thời điểm nào đó. Nhu cầu này phát sinh, chẳng hạn như khi một ứng dụng cần chuyển từ màn hình hiện tại sang cái mới.

Tuỳ thuộc vào việc hoạt động của bạn có muốn nhận lại kết quả từ hoạt động mới hay không quảng cáo sắp bắt đầu, bạn hãy bắt đầu hoạt động mới bằng cách sử dụng startActivity() hoặc startActivityForResult() . Trong cả hai trường hợp, bạn truyền vào đối tượng Intent.

Đối tượng Intent chỉ định giá trị chính xác hoạt động bạn muốn bắt đầu hoặc mô tả loại hành động bạn muốn thực hiện. Hệ thống sẽ chọn hoạt động thích hợp cho bạn, thậm chí có thể là từ một ứng dụng khác. Đối tượng Intent có thể cũng mang một lượng nhỏ dữ liệu dùng cho hoạt động bắt đầu. Để biết thêm thông tin về lớp Intent, hãy xem Ý định và ý định Bộ lọc.

startActivity()

Nếu hoạt động mới bắt đầu không cần trả về kết quả, thì hoạt động hiện tại có thể khởi động hoạt động đó bằng cách gọi startActivity() .

Khi làm việc trong ứng dụng của riêng mình, thông thường bạn chỉ cần khởi chạy một hoạt động đã biết. Ví dụ: đoạn mã sau đây cho biết cách khởi chạy một hoạt động có tên là SignInActivity.

Kotlin

val intent = Intent(this, SignInActivity::class.java)
startActivity(intent)

Java

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);

Ứng dụng của bạn cũng có thể muốn thực hiện một số thao tác, chẳng hạn như gửi email, tin nhắn văn bản hoặc thông tin cập nhật trạng thái sử dụng dữ liệu từ hoạt động của bạn. Trong trường hợp này, ứng dụng của bạn có thể không có hoạt động riêng để thực hiện những thao tác đó, để bạn có thể tận dụng các hoạt động do các ứng dụng khác trên thiết bị cung cấp, có thể thực hiện hành động cho bạn.

Đây là khi ý định thực sự có giá trị. Bạn có thể tạo một ý định mô tả hành động bạn muốn thực hiện và hệ thống khởi chạy các thao tác thích hợp hoạt động từ một ứng dụng khác. Nếu có nhiều hoạt động có thể xử lý ý định, thì người dùng có thể chọn định dạng nào sẽ sử dụng. Ví dụ: nếu bạn muốn cho phép người dùng gửi một nội dung email, bạn có thể tạo ý định sau:

Kotlin

val intent = Intent(Intent.ACTION_SEND).apply {
    putExtra(Intent.EXTRA_EMAIL, recipientArray)
}
startActivity(intent)

Java

Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);

Phần bổ sung EXTRA_EMAIL được thêm vào ý định là một mảng chuỗi của địa chỉ email mà bạn muốn gửi đến. Khi ứng dụng email phản hồi ý định này, nó sẽ đọc mảng chuỗi được cung cấp trong phần bổ sung và đặt địa chỉ ở trường "đến" của biểu mẫu soạn email. Trong phần này tình huống cụ thể, hoạt động của ứng dụng email bắt đầu và khi người dùng hoàn tất, hoạt động của bạn tiếp tục.

startActivityForResult()

Đôi khi, bạn muốn nhận lại kết quả từ một hoạt động khi hoạt động đó kết thúc. Ví dụ: bạn có thể bắt đầu một hoạt động cho phép người dùng chọn một người trong danh sách người liên hệ. Khi kết thúc, hàm này sẽ trả về người đã được chọn. Để thực hiện việc này, bạn gọi hàm startActivityForResult(Intent, int) trong đó tham số số nguyên xác định lệnh gọi.

Giá trị nhận dạng này dùng để phân biệt giữa nhiều lệnh gọi đến startActivityForResult(Intent, int) khỏi cùng một hoạt động. Đây không phải là giá trị nhận dạng chung và không có nguy cơ xung đột với các ứng dụng hoặc hoạt động khác. Kết quả trở lại thông qua onActivityResult(int, int, Intent) .

Khi thoát, một hoạt động con có thể gọi setResult(int) để trả về dữ liệu cho thành phần mẹ. Hoạt động con phải cung cấp một mã kết quả, đây có thể là kết quả chuẩn RESULT_CANCELED, RESULT_OK hoặc giá trị tuỳ chỉnh bất kỳ giá từ RESULT_FIRST_USER.

Ngoài ra, hoạt động con có thể tuỳ ý trả về một Intent chứa bất kỳ dữ liệu bổ sung nào mà đối tượng đó muốn. Hoạt động gốc sử dụng onActivityResult(int, int, Intent) cùng với giá trị nhận dạng số nguyên của hoạt động gốc được cung cấp, để nhận thông tin.

Nếu một hoạt động con không thành công vì bất kỳ lý do gì, chẳng hạn như gặp sự cố, thì phần tử mẹ hoạt động sẽ nhận được kết quả có mã RESULT_CANCELED.

Kotlin

class MyActivity : Activity() {
    // ...

    override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
            // When the user center presses, let them pick a contact.
            startActivityForResult(
                    Intent(Intent.ACTION_PICK,Uri.parse("content://contacts")),
                    PICK_CONTACT_REQUEST)
            return true
        }
        return false
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
        when (requestCode) {
            PICK_CONTACT_REQUEST ->
                if (resultCode == RESULT_OK) {
                    // A contact was picked. Display it to the user.
                    startActivity(Intent(Intent.ACTION_VIEW, intent?.data))
                }
        }
    }

    companion object {
        internal val PICK_CONTACT_REQUEST = 0
    }
}

Java

public class MyActivity extends Activity {
     // ...

     static final int PICK_CONTACT_REQUEST = 0;

     public boolean onKeyDown(int keyCode, KeyEvent event) {
         if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
             // When the user center presses, let them pick a contact.
             startActivityForResult(
                 new Intent(Intent.ACTION_PICK,
                 new Uri("content://contacts")),
                 PICK_CONTACT_REQUEST);
            return true;
         }
         return false;
     }

     protected void onActivityResult(int requestCode, int resultCode,
             Intent data) {
         if (requestCode == PICK_CONTACT_REQUEST) {
             if (resultCode == RESULT_OK) {
                 // A contact was picked. Display it to the user.
                 startActivity(new Intent(Intent.ACTION_VIEW, data));
             }
         }
     }
 }

Điều phối các hoạt động

Khi một hoạt động bắt đầu một hoạt động khác, cả hai đều trải qua quá trình chuyển đổi vòng đời. Hoạt động đầu tiên ngừng hoạt động và chuyển sang trạng thái Đã tạm dừng hoặc Đã dừng, trong khi hoạt động còn lại các hoạt động được tạo ra. Trong trường hợp những hoạt động này chia sẻ dữ liệu đã lưu vào đĩa hoặc nơi khác, đó là bạn cần hiểu rằng hoạt động đầu tiên không bị dừng hoàn toàn trước hoạt động thứ hai sẽ được tạo. Đúng hơn, quy trình bắt đầu quy trình thứ hai trùng lặp với quy trình ngừng bài đăng đầu tiên.

Thứ tự của các phương thức gọi lại trong vòng đời được xác định rõ, đặc biệt khi hai hoạt động được xác định trong cùng một quy trình, hay nói cách khác là trên cùng một ứng dụng và một ứng dụng sẽ bắt đầu cái kia. Sau đây là thứ tự diễn ra các thao tác khi Hoạt động A bắt đầu Hoạt động B:

1. Phương thức onPause() của hoạt động A sẽ được thực thi.
2. onCreate() của Hoạt động B, onStart() và Các phương thức onResume() thực thi theo trình tự. Hoạt động B hiện được người dùng tập trung vào.
3. Nếu Hoạt động A không còn hiển thị trên màn hình, thì phương thức onStop() của Hoạt động đó sẽ được thực thi.

Trình tự các phương thức gọi lại trong vòng đời này cho phép bạn quản lý quá trình chuyển đổi thông tin từ hoạt động này sang hoạt động khác.