Android มีกลไกในการปิดแอปพลิเคชันอย่างปลอดภัยตามเอกสารของมัน ในกิจกรรมล่าสุดที่ออก (โดยปกติคือกิจกรรมหลักที่เกิดขึ้นครั้งแรกเมื่อแอปพลิเคชันเริ่มต้น) เพียงวางสองบรรทัดในเมธอด onDestroy () การเรียกใช้System.runFinalizersOnExit (true)ทำให้แน่ใจว่าวัตถุทั้งหมดจะถูกสรุปและรวบรวมขยะเมื่อแอปพลิเคชันออก นอกจากนี้คุณยังสามารถฆ่าแอปพลิเคชันได้อย่างรวดเร็วผ่านandroid.os.Process.killProcess (android.os.Process.myPid ()) หากคุณต้องการ วิธีที่ดีที่สุดในการทำเช่นนี้คือใส่วิธีการดังต่อไปนี้ในคลาสผู้ช่วยแล้วเรียกมันว่าเมื่อใดก็ตามที่แอปจำเป็นต้องถูกฆ่า ตัวอย่างเช่นในวิธีการทำลายของกิจกรรมรูท (สมมติว่าแอปไม่เคยฆ่ากิจกรรมนี้):
Android จะไม่แจ้งเตือนแอปพลิเคชันของเหตุการณ์ปุ่มHOMEดังนั้นคุณจึงไม่สามารถปิดแอปพลิเคชันได้เมื่อกดปุ่มHOME Android ขอสงวน ปุ่มหน้าแรกด้วยตนเองเพื่อให้ผู้พัฒนาไม่สามารถป้องกันผู้ใช้ออกจากแอปพลิเคชันได้ อย่างไรก็ตามคุณสามารถกำหนดได้ด้วยการกดปุ่มHOMEโดยการตั้งค่าสถานะเป็นจริงในคลาสผู้ช่วยซึ่งถือว่ามีการกดปุ่มHOMEจากนั้นเปลี่ยนค่าสถานะเป็นเท็จเมื่อมีเหตุการณ์เกิดขึ้นซึ่งแสดงว่าปุ่มHOMEไม่ได้ถูกกด การตรวจสอบเพื่อดูปุ่มโฮมที่กดในวิธีonStop ()ของกิจกรรม
อย่าลืมจัดการกับปุ่มHOMEสำหรับเมนูใด ๆ และในกิจกรรมที่เริ่มโดยเมนู เช่นเดียวกันกับปุ่มSEARCH ด้านล่างเป็นตัวอย่างคลาสที่จะแสดง:
นี่คือตัวอย่างของกิจกรรมรูทที่ฆ่าแอปพลิเคชันเมื่อมันถูกทำลาย:
package android.example;
/**
* @author Danny Remington - MacroSolve
*/
public class HomeKey extends CustomActivity {
public void onDestroy() {
super.onDestroy();
/*
* Kill application when the root activity is killed.
*/
UIHelper.killApp(true);
}
}
ต่อไปนี้เป็นกิจกรรมนามธรรมที่สามารถขยายเพื่อจัดการคีย์HOMEสำหรับกิจกรรมทั้งหมดที่ขยาย:
package android.example;
/**
* @author Danny Remington - MacroSolve
*/
import android.app.Activity;
import android.view.Menu;
import android.view.MenuInflater;
/**
* Activity that includes custom behavior shared across the application. For
* example, bringing up a menu with the settings icon when the menu button is
* pressed by the user and then starting the settings activity when the user
* clicks on the settings icon.
*/
public abstract class CustomActivity extends Activity {
public void onStart() {
super.onStart();
/*
* Check if the app was just launched. If the app was just launched then
* assume that the HOME key will be pressed next unless a navigation
* event by the user or the app occurs. Otherwise the user or the app
* navigated to this activity so the HOME key was not pressed.
*/
UIHelper.checkJustLaunced();
}
public void finish() {
/*
* This can only invoked by the user or the app finishing the activity
* by navigating from the activity so the HOME key was not pressed.
*/
UIHelper.homeKeyPressed = false;
super.finish();
}
public void onStop() {
super.onStop();
/*
* Check if the HOME key was pressed. If the HOME key was pressed then
* the app will be killed. Otherwise the user or the app is navigating
* away from this activity so assume that the HOME key will be pressed
* next unless a navigation event by the user or the app occurs.
*/
UIHelper.checkHomeKeyPressed(true);
}
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.settings_menu, menu);
/*
* Assume that the HOME key will be pressed next unless a navigation
* event by the user or the app occurs.
*/
UIHelper.homeKeyPressed = true;
return true;
}
public boolean onSearchRequested() {
/*
* Disable the SEARCH key.
*/
return false;
}
}
นี่คือตัวอย่างของหน้าจอเมนูที่จัดการปุ่มHOME :
/**
* @author Danny Remington - MacroSolve
*/
package android.example;
import android.os.Bundle;
import android.preference.PreferenceActivity;
/**
* PreferenceActivity for the settings screen.
*
* @see PreferenceActivity
*
*/
public class SettingsScreen extends PreferenceActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.layout.settings_screen);
}
public void onStart() {
super.onStart();
/*
* This can only invoked by the user or the app starting the activity by
* navigating to the activity so the HOME key was not pressed.
*/
UIHelper.homeKeyPressed = false;
}
public void finish() {
/*
* This can only invoked by the user or the app finishing the activity
* by navigating from the activity so the HOME key was not pressed.
*/
UIHelper.homeKeyPressed = false;
super.finish();
}
public void onStop() {
super.onStop();
/*
* Check if the HOME key was pressed. If the HOME key was pressed then
* the app will be killed either safely or quickly. Otherwise the user
* or the app is navigating away from the activity so assume that the
* HOME key will be pressed next unless a navigation event by the user
* or the app occurs.
*/
UIHelper.checkHomeKeyPressed(true);
}
public boolean onSearchRequested() {
/*
* Disable the SEARCH key.
*/
return false;
}
}
นี่คือตัวอย่างของคลาสตัวช่วยที่จัดการกับปุ่มHOMEทั่วทั้งแอป:
package android.example;
/**
* @author Danny Remington - MacroSolve
*
*/
/**
* Helper class to help handling of UI.
*/
public class UIHelper {
public static boolean homeKeyPressed;
private static boolean justLaunched = true;
/**
* Check if the app was just launched. If the app was just launched then
* assume that the HOME key will be pressed next unless a navigation event
* by the user or the app occurs. Otherwise the user or the app navigated to
* the activity so the HOME key was not pressed.
*/
public static void checkJustLaunced() {
if (justLaunched) {
homeKeyPressed = true;
justLaunched = false;
} else {
homeKeyPressed = false;
}
}
/**
* Check if the HOME key was pressed. If the HOME key was pressed then the
* app will be killed either safely or quickly. Otherwise the user or the
* app is navigating away from the activity so assume that the HOME key will
* be pressed next unless a navigation event by the user or the app occurs.
*
* @param killSafely
* Primitive boolean which indicates whether the app should be
* killed safely or quickly when the HOME key is pressed.
*
* @see {@link UIHelper.killApp}
*/
public static void checkHomeKeyPressed(boolean killSafely) {
if (homeKeyPressed) {
killApp(true);
} else {
homeKeyPressed = true;
}
}
/**
* Kill the app either safely or quickly. The app is killed safely by
* killing the virtual machine that the app runs in after finalizing all
* {@link Object}s created by the app. The app is killed quickly by abruptly
* killing the process that the virtual machine that runs the app runs in
* without finalizing all {@link Object}s created by the app. Whether the
* app is killed safely or quickly the app will be completely created as a
* new app in a new virtual machine running in a new process if the user
* starts the app again.
*
* <P>
* <B>NOTE:</B> The app will not be killed until all of its threads have
* closed if it is killed safely.
* </P>
*
* <P>
* <B>NOTE:</B> All threads running under the process will be abruptly
* killed when the app is killed quickly. This can lead to various issues
* related to threading. For example, if one of those threads was making
* multiple related changes to the database, then it may have committed some
* of those changes but not all of those changes when it was abruptly
* killed.
* </P>
*
* @param killSafely
* Primitive boolean which indicates whether the app should be
* killed safely or quickly. If true then the app will be killed
* safely. Otherwise it will be killed quickly.
*/
public static void killApp(boolean killSafely) {
if (killSafely) {
/*
* Notify the system to finalize and collect all objects of the app
* on exit so that the virtual machine running the app can be killed
* by the system without causing issues. NOTE: If this is set to
* true then the virtual machine will not be killed until all of its
* threads have closed.
*/
System.runFinalizersOnExit(true);
/*
* Force the system to close the app down completely instead of
* retaining it in the background. The virtual machine that runs the
* app will be killed. The app will be completely created as a new
* app in a new virtual machine running in a new process if the user
* starts the app again.
*/
System.exit(0);
} else {
/*
* Alternatively the process that runs the virtual machine could be
* abruptly killed. This is the quickest way to remove the app from
* the device but it could cause problems since resources will not
* be finalized first. For example, all threads running under the
* process will be abruptly killed when the process is abruptly
* killed. If one of those threads was making multiple related
* changes to the database, then it may have committed some of those
* changes but not all of those changes when it was abruptly killed.
*/
android.os.Process.killProcess(android.os.Process.myPid());
}
}
}