Đóng ứng dụng và khởi chạy màn hình chính trên Android

Tôi có hai hoạt động khác nhau. Chiếc đầu tiên ra mắt chiếc thứ hai. Trong hoạt động thứ hai, tôi gọi System.exit(0)để buộc đóng ứng dụng, nhưng hoạt động đầu tiên sẽ tự động hiển thị thay vì ứng dụng quay lại màn hình chính. Làm cách nào để tránh điều này và đưa ứng dụng quay lại màn hình chính?

Bạn thực sự nên nghĩ đến việc không thoát ứng dụng. Đây không phải là cách các ứng dụng Android thường hoạt động.

Câu trả lời ngắn gọn: hãy gọi moveTaskToBack(true)cho bạnActivity thay vì System.exit(). Thao tác này sẽ ẩn ứng dụng của bạn cho đến khi người dùng muốn sử dụng lại.

Câu trả lời dài hơn bắt đầu với một câu hỏi khác: tại sao bạn muốn hủy ứng dụng của mình?

Hệ điều hành Android xử lý các quy trình và quản lý bộ nhớ, v.v. vì vậy lời khuyên của tôi là hãy để Android lo việc này cho bạn. Nếu người dùng muốn rời khỏi ứng dụng của bạn, họ có thể nhấn nút Trang chủ và ứng dụng của bạn sẽ biến mất một cách hiệu quả. Nếu sau này điện thoại cần thêm bộ nhớ thì hệ điều hành sẽ chấm dứt ứng dụng của bạn.

Miễn là bạn đang phản hồi các sự kiện vòng đời một cách thích hợp , cả bạn và người dùng đều không cần quan tâm đến việc ứng dụng của bạn có còn đang chạy hay không.

Vì vậy, nếu bạn muốn ẩn cuộc gọi ứng dụng của mình moveTaskToBack()và để Android quyết định khi nào sẽ giết nó.

Cách dễ nhất để đạt được điều này được đưa ra dưới đây (mà không ảnh hưởng đến việc quản lý bộ nhớ gốc của Android. Không có quá trình giết chết liên quan).

1. Khởi chạy một hoạt động bằng Intent này:

   Intent intent = new Intent(this, FinActivity.class);
   intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
   startActivity(intent);
   finish();
   

2. Trong hoạt động đích FinActivity.class, hãy gọi finish () trong onCreate.

Các bước được giải thích:

1. Bạn tạo một ý định xóa tất cả các hoạt động khác (FLAG_ACTIVITY_CLEAR_TOP)và xóa hoạt động hiện tại.

2. Hoạt động phá hủy chính nó. Một cách khác là bạn có thể tạo một màn hình giật gân trong finActivity. Đây là tùy chọn.

Android có sẵn một cơ chế để đóng ứng dụng một cách an toàn theo tài liệu của nó. Trong Activity cuối cùng được thoát (thường là Activity chính xuất hiện đầu tiên khi ứng dụng khởi động), chỉ cần đặt một vài dòng trong phương thức onDestroy (). Lời gọi đến System.runFinalizersOnExit (true) đảm bảo rằng tất cả các đối tượng sẽ được hoàn thiện và thu gom rác khi ứng dụng thoát. Ví dụ:

public void onDestroy() {
    super.onDestroy();

    /*
     * Notify the system to finalize and collect all objects of the
     * application on exit so that the process running the application can
     * be killed by the system without causing issues. NOTE: If this is set
     * to true then the process will not be killed until all of its threads
     * have closed.
     */
    System.runFinalizersOnExit(true);

    /*
     * Force the system to close the application down completely instead of
     * retaining it in the background. The process that runs the application
     * will be killed. The application will be completely created as a new
     * application in a new process if the user starts the application
     * again.
     */
    System.exit(0);
}

Cuối cùng Android sẽ không thông báo cho một ứng dụng về sự kiện phím HOME , vì vậy bạn không thể đóng ứng dụng khi nhấn phím HOME . Android bảo lưu sự kiện khóa HOME cho chính nó để nhà phát triển không thể ngăn người dùng rời khỏi ứng dụng của họ.

Bạn cũng có thể chỉ định noHistory = "true" trong thẻ cho hoạt động đầu tiên hoặc kết thúc hoạt động đầu tiên ngay sau khi bạn bắt đầu hoạt động thứ hai (như David đã nói).

AFAIK, "buộc đóng" sẽ giết quá trình lưu trữ JVM trong đó ứng dụng của bạn chạy và System.exit () chấm dứt JVM đang chạy phiên bản ứng dụng của bạn. Cả hai đều là hình thức chấm dứt đột ngột và không được khuyến khích cho dòng ứng dụng thông thường.

Cũng như việc bắt các ngoại lệ để bao gồm các luồng logic mà một chương trình có thể thực hiện, là không nên.

Tôi sử dụng phương pháp này để đóng các Hoạt động!

public static void closeAllBelowActivities(Activity current) {
    boolean flag = true;
    Activity below = current.getParent();
    if (below == null)
        return;
    System.out.println("Below Parent: " + below.getClass());
    while (flag) {
        Activity temp = below;
        try {
            below = temp.getParent();
            temp.finish();
        } catch (Exception e) {
            flag = false;
        }
    }
}

Khi bạn khởi chạy hoạt động thứ hai, hoạt động finish()đầu tiên ngay lập tức:

startActivity(new Intent(...));
finish();

android.os.Process.killProcess(android.os.Process.myPid()); hoạt động tốt, nhưng bạn nên để nền tảng Android lo lắng về việc quản lý bộ nhớ :-)

Bạn không thể thực hiện System.exit (), nó không an toàn.

Bạn có thể làm điều này: Process.killProcess (Process.myPid ());

Tôi sử dụng cái này:

1) Hoạt động chính gọi hoạt động phụ với phương thức "startActivityForResult"

2) Trong hoạt động phụ khi kết thúc:

int exitCode = 1; // Select the number you want
setResult(exitCode);
finish();

3) Và trong hoạt động mẹ ghi đè phương thức "onActivityResult":

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    int exitCode = 1;
    if(resultCode == exitCode) {
        super.setResult(exitCode); // use this if you have more than 2 activities
        finish();
    }
}

Cái này làm việc tốt cho tôi.

Sử dụng finishphương pháp. Đây là phương pháp đơn giản và dễ dàng hơn.

this.finish();

Hãy nhớ rằng khi làm việc với các ứng dụng sử dụng kết nối ổ cắm liên tục, finish()phương pháp này không giải phóng kết nối. Trong những trường hợp bình thường, finish()là lựa chọn tốt nhất, nhưng nếu bạn thực sự cần thoát khỏi một ứng dụng và giải phóng tất cả tài nguyên mà nó đang sử dụng thì hãy sử dụng killProcess. Tôi không gặp vấn đề gì khi sử dụng nó.

Bắt đầu hoạt động thứ hai với startActivityForResult và trong hoạt động thứ hai trả về một giá trị, mà một khi trong phương thức onActivityResult của hoạt động đầu tiên sẽ đóng ứng dụng chính. Tôi nghĩ đây là cách chính xác của Android.

Bạn sai rồi. Có một cách để hủy một ứng dụng. Trong một lớp có Ứng dụng siêu lớp, chúng ta sử dụng một số trường, chẳng hạn killApp. Khi chúng tôi bắt đầu màn hình giật gân (hoạt động đầu tiên) trong onResume(), chúng tôi đặt một tham số là false cho trường killApp. Trong mọi hoạt động mà chúng ta có khi onResume()cuối cùng được gọi, chúng ta gọi một cái gì đó như thế:

if(AppClass.killApp())
    finish();

Mọi hoạt động được hiển thị trên màn hình đều phải gọi onResume(). Khi nó được gọi, chúng ta phải kiểm tra xem trường của chúng ta killAppcó đúng không. Nếu nó là đúng, các hoạt động hiện tại sẽ gọi finish(). Để gọi toàn bộ hành động, chúng tôi sử dụng cấu trúc tiếp theo. Ví dụ: trong hành động cho một nút:

AppClass.setkillApplication(true);
   finish();
   return;

Hãy thử những điều sau đây. Nó làm việc cho tôi.

ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1); 
ComponentName componentInfo = taskInfo.get(0).topActivity;
am.restartPackage(componentInfo.getPackageName());

Giả sử bạn có ngăn xếp hoạt động như A> B> C> D> E. Bạn đang ở hoạt động D và bạn muốn đóng ứng dụng của mình. Đây là những gì bạn sẽ làm -

Trong Hoạt động từ nơi bạn muốn đóng (Hoạt động D) -

Intent intent = new Intent(D.this,A.class);
intent.putExtra("exit", "exit");
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivity(intent);

Trong RootActivity của bạn (tức là hoạt động cơ sở của bạn, ở đây là Hoạt động A) -

@Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (intent.hasExtra("exit")) {
            setIntent(intent);
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (getIntent() != null) {
            if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) {
                onBackPressed();
            }
        }
    }

onNewIntent được sử dụng vì nếu hoạt động còn tồn tại, nó sẽ nhận được ý định đầu tiên bắt đầu nó. Không phải cái mới. Để biết thêm chi tiết - Tài liệu

Nó thực sự yên tĩnh dễ dàng.

Cách tôi làm điều này là lưu một cờ trong một biến tĩnh có sẵn cho tất cả. Sau đó, khi tôi thoát ra, tôi đặt cờ này và mọi hoạt động của tôi sẽ kiểm tra cờ này onResume. Nếu cờ được đặt thì tôi sẽ phát hànhSystem.exit cho hoạt động đó.

Bằng cách đó, tất cả các hoạt động sẽ kiểm tra cờ và sẽ đóng một cách duyên dáng nếu cờ được đặt.

Đây là những gì tôi đã làm để đóng ứng dụng: Trong ứng dụng của tôi, tôi có một lớp hoạt động cơ sở, tôi đã thêm một cờ tĩnh có tên "applicationShutDown". Khi tôi cần đóng ứng dụng, tôi đặt nó thành true.

Trong hoạt động cơ sở onCreate và onResume sau khi gọi các lệnh gọi siêu tôi kiểm tra cờ này. Nếu "applicationShutDown" là true, tôi gọi là kết thúc Hoạt động hiện tại.

Điều này đã làm việc cho tôi:

protected void onResume() {
    super.onResume();
    if(BaseActivity.shutDownApp)
    {
        finish();
        return;

    }}

Chạy hoạt động thứ hai bằng cách sử dụng hoạt động bắt đầu để có kết quả:

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);

//This line is important
intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);

startActivityForResult(intent, REQUEST_CODE);

Thêm chức năng này vào Hoạt động đầu tiên:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if(rquestCode == REQUEST_CODE)
        if(resultCode == RESULT_CANCELED)
            finish();
}

Và thêm điều này vào Hoạt động thứ hai:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {

        Log.i(TAG, "Back key pressed");
        setResult(RESULT_CANCELED);
        finish();
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

Nó không được khuyến khích, nhưng bạn vẫn có thể sử dụng cái này. Tốt hơn nên sử dụng giải pháp này trong trường hợp bạn cần thoát ứng dụng.

Theo tôi, giải pháp tốt nhất là hoàn thành mọi hoạt động trong ứng dụng của bạn như bên dưới.

Bước 1. Duy trì một biến tĩnh trong mainactivity. Nói,

public static boolean isQuit = false;

Bước 2. Khi nhấp vào sự kiện của một nút, hãy đặt biến này thành true.

mainactivity.isQuit = true;
finish();

Bước 3. Và trong mọi hoạt động của ứng dụng của bạn, có onrestartphương pháp như bên dưới.

@Override
protected void onRestart() {
    // TODO Auto-generated method stub
    super.onRestart();
    if(mainactivity.isQuit)
        finish();
}

Tôi đã giải quyết một vấn đề tương tự: MainActivity khởi động BrowserActivity và tôi cần đóng ứng dụng khi người dùng nhấn Quay lại trong BrowserActivity - không quay lại trong MainActivity. Vì vậy, trong MainActivity:

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "sm500_Rmt.MainActivity";
    private boolean m_IsBrowserStarted = false;

và sau đó, trong OnResume:

    @Override
protected void onResume() {
    super.onResume();
    if(m_IsBrowserStarted) {
        Log.w(TAG, "onResume, but it's return from browser, just exit!");
        finish();
        return;
    }
    Log.w(TAG, "onResume");

... sau đó tiếp tục OnResume. Và, khi khởi động BrowserActivity:

    Intent intent = new Intent(this, BrowserActivity.class);
    intent.putExtra(getString(R.string.IPAddr), ip);
    startActivity(intent);
    m_IsBrowserStarted = true;

Và có vẻ như nó hoạt động tốt! :-)