การออกจากแอปพลิเคชันขมวดคิ้วอยู่หรือไม่?

ย้ายที่ในความพยายามของฉันที่จะเรียนรู้ Android ผมก็อ่านต่อไปนี้ :

คำถาม: ผู้ใช้มีตัวเลือกในการฆ่าแอปพลิเคชันหรือไม่ถ้าเราไม่ใส่ตัวเลือกเมนูเพื่อฆ่ามัน? หากไม่มีตัวเลือกดังกล่าวผู้ใช้จะยกเลิกแอปพลิเคชันอย่างไร

คำตอบ: (Romain Guy): ผู้ใช้ไม่ได้ระบบจะจัดการสิ่งนี้โดยอัตโนมัติ นั่นคือสิ่งที่วงจรชีวิตของกิจกรรม (โดยเฉพาะ onPause / onStop / onDestroy) มีไว้สำหรับ ไม่ว่าคุณจะทำอะไรอย่าใส่ปุ่มแอปพลิเคชัน "ออกจาก" หรือ "ออก" มันไม่มีประโยชน์กับแอปพลิเคชันของ Android นี่เป็นสิ่งที่ตรงกันข้ามกับวิธีการทำงานของแอปพลิเคชันหลัก

Hehe สำหรับทุกขั้นตอนที่ฉันทำในโลก Android ฉันพบปัญหาบางอย่าง = (

เห็นได้ชัดว่าคุณไม่สามารถออกจากแอปพลิเคชันใน Android (แต่ระบบ Android สามารถทำลายแอปของคุณได้อย่างสมบูรณ์เมื่อใดก็ตามที่รู้สึกเหมือนมัน) เกิดอะไรขึ้นกับสิ่งนั้น ฉันเริ่มคิดว่ามันเป็นไปไม่ได้ที่จะเขียนแอพที่ทำหน้าที่เป็น "แอพปกติ" - ผู้ใช้สามารถออกจากแอพเมื่อเขา / เธอตัดสินใจที่จะทำ นั่นไม่ใช่สิ่งที่ควรเชื่อถือได้กับระบบปฏิบัติการที่ต้องทำ

แอปพลิเคชันที่ฉันพยายามสร้างไม่ใช่แอปพลิเคชันสำหรับ Android Market มันไม่ใช่แอปพลิเคชันสำหรับ "การใช้งานทั่วไป" โดยบุคคลทั่วไปมันเป็นแอพทางธุรกิจที่จะใช้ในธุรกิจที่แคบมาก

จริง ๆ แล้วฉันตั้งตาคอยที่จะพัฒนาแพลตฟอร์ม Android เพราะมันจัดการปัญหามากมายที่มีอยู่ใน Windows Mobile และ. NET อย่างไรก็ตามสัปดาห์ที่ผ่านมาเป็นการเปิดตัวสำหรับฉัน ... ฉันหวังว่าฉันจะไม่ต้องละทิ้ง Android แต่ตอนนี้มันดูไม่ดีเลยตอนนี้ = (

มีวิธีที่ฉันจะออกจากแอปพลิเคชันจริง ๆหรือไม่?

ในที่สุดนี้จะได้รับคำถามของคุณ แต่ก่อนอื่นฉันต้องการที่จะแก้ไขปัญหาจำนวนมากที่คุณแสดงความคิดเห็นที่หลากหลายของคุณกับคำตอบต่าง ๆ ที่ได้รับแล้วในขณะที่เขียนนี้ ฉันไม่มีความตั้งใจที่จะเปลี่ยนใจ - แต่สิ่งเหล่านี้อยู่ที่นี่สำหรับคนอื่น ๆ ที่มาอ่านโพสต์นี้ในอนาคต

ประเด็นก็คือฉันไม่สามารถอนุญาตให้ Android ระบุว่าแอพของฉันจะถูกยกเลิกเมื่อใด ที่จะต้องเป็นทางเลือกของผู้ใช้

ผู้คนนับล้านมีความสุขอย่างสมบูรณ์แบบกับโมเดลที่สภาพแวดล้อมปิดแอปพลิเคชันตามต้องการ ผู้ใช้เหล่านั้นไม่ได้คิดเกี่ยวกับ "ยุติ" แอพ Android มากกว่าที่พวกเขาคิดเกี่ยวกับ "ยกเลิก" หน้าเว็บหรือ "ยุติ" เทอร์โม

ผู้ใช้ iPhone มีวิธีการเดียวกันมากในการกดปุ่ม iPhone ไม่จำเป็นต้อง "รู้สึก" เหมือนแอพที่ถูกยกเลิกเนื่องจากแอพของ iPhone จำนวนมากเลือกที่ที่ผู้ใช้ทิ้งไว้แม้ว่าแอปจะถูกปิดจริงๆ (ตั้งแต่ iPhone เท่านั้น อนุญาตให้แอปของบุคคลที่สามหนึ่งรายการพร้อมกันในปัจจุบัน)

ดังที่ฉันได้กล่าวไว้ข้างต้นมีหลายสิ่งที่เกิดขึ้นในแอปของฉัน (ข้อมูลถูกผลักดันไปยังอุปกรณ์

ฉันไม่ทราบว่า "รายการที่มีงานที่ควรมี" หมายถึงอะไร แต่ "ข้อมูลที่ถูกผลักไปยังอุปกรณ์" เป็นนิยายที่น่าพอใจและไม่ควรทำโดยกิจกรรมใด ๆ ใช้งานที่กำหนดเวลาไว้ (ผ่านAlarmManager) เพื่ออัปเดตข้อมูลของคุณเพื่อความน่าเชื่อถือสูงสุด

ผู้ใช้ของเราเข้าสู่ระบบและไม่สามารถทำเช่นนั้นได้ทุกครั้งที่พวกเขาได้รับโทรศัพท์และ Android ตัดสินใจที่จะฆ่าแอพ

มีแอปพลิเคชั่น iPhone และ Android มากมายที่จัดการกับสิ่งนี้ โดยปกติจะเป็นเพราะพวกเขาเก็บข้อมูลรับรองการเข้าสู่ระบบแทนที่จะบังคับให้ผู้ใช้เข้าสู่ระบบทุกครั้งด้วยตนเอง

ตัวอย่างเช่นเราต้องการตรวจสอบการอัปเดตเมื่อออกจากแอปพลิเคชัน

นั่นเป็นข้อผิดพลาดในระบบปฏิบัติการใด ๆ สำหรับสิ่งที่คุณรู้เหตุผลที่แอปพลิเคชันของคุณกำลัง "ออก" เป็นเพราะระบบปฏิบัติการปิดตัวลงแล้วกระบวนการอัปเดตของคุณจะล้มเหลวในช่วงกลางสตรีม โดยทั่วไปนั่นไม่ใช่สิ่งที่ดี ตรวจสอบการอัปเดตเมื่อเริ่มหรือตรวจสอบการอัปเดตแบบอะซิงโครนัสทั้งหมด (เช่นผ่านงานที่กำหนด) ไม่เคยออก

ความคิดเห็นบางข้อแนะนำว่าการกดปุ่มย้อนกลับไม่ได้ฆ่าแอพเลย (ดูลิงก์ในคำถามของฉันด้านบน)

การกดปุ่มย้อนกลับไม่ได้ "ฆ่าแอพ" กิจกรรมจะเสร็จสิ้นบนหน้าจอเมื่อผู้ใช้กดปุ่ม BACK

ควรสิ้นสุดเมื่อผู้ใช้ต้องการยกเลิกเท่านั้น - ไม่เคยมีวิธีอื่นใด หากคุณไม่สามารถเขียนแอพที่มีพฤติกรรมเช่นนั้นใน Android ได้ฉันคิดว่า Android ไม่สามารถใช้สำหรับการเขียนแอพจริง = (

จากนั้นไม่สามารถใช้งานเว็บแอปพลิเคชันได้ หรือWebOSถ้าฉันเข้าใจโมเดลของพวกเขาถูกต้อง (ยังไม่มีโอกาสได้เล่นด้วย) ในสิ่งเหล่านี้ผู้ใช้จะไม่ "ยุติ" สิ่งใดเลย - พวกเขาเพิ่งจากไป iPhone นั้นแตกต่างกันเล็กน้อยซึ่งในปัจจุบันมีเพียงสิ่งเดียวเท่านั้นที่อนุญาตให้เรียกใช้ในแต่ละครั้ง

มีวิธีที่ฉันจะออกจากแอปพลิเคชันจริง ๆ หรือไม่?

ตามที่ทุกคนบอกคุณผู้ใช้ (ผ่านทาง BACK) หรือรหัสของคุณ (ผ่านfinish()) สามารถปิดกิจกรรมที่กำลังดำเนินอยู่ โดยทั่วไปผู้ใช้ไม่ต้องการสิ่งใดสำหรับแอปพลิเคชันที่เขียนอย่างถูกต้องมากกว่าที่พวกเขาต้องการตัวเลือก "ออกจาก" สำหรับการใช้งานเว็บแอปพลิเคชัน

ไม่มีสองสภาพแวดล้อมของแอปพลิเคชันเหมือนกันตามคำจำกัดความ ซึ่งหมายความว่าคุณสามารถเห็นแนวโน้มในสภาพแวดล้อมเมื่อมีสิ่งใหม่เกิดขึ้นและอื่น ๆ ถูกฝังอยู่

ตัวอย่างเช่นมีการเคลื่อนไหวเพิ่มขึ้นเพื่อพยายามกำจัดความคิดของ "ไฟล์" เว็บแอพพลิเคชั่นส่วนใหญ่ไม่บังคับให้ผู้ใช้นึกถึงไฟล์ต่างๆ โดยทั่วไปแล้วแอพของ iPhone จะไม่บังคับให้ผู้ใช้นึกถึงไฟล์ต่างๆ แอพ Android มักจะไม่บังคับให้ผู้ใช้นึกถึงไฟล์ต่างๆ และอื่น ๆ

ในทำนองเดียวกันมีการเคลื่อนไหวที่เพิ่มขึ้นเพื่อพยายามกำจัดความคิดของ "ยุติ" แอพ แอปพลิเคชั่นเว็บส่วนใหญ่ไม่ได้บังคับให้ผู้ใช้ออกจากระบบ แต่เป็นการออกจากระบบโดยปริยายหลังจากผู้ใช้ไม่มีกิจกรรม สิ่งเดียวกันกับ Android และ iPhone (และอาจเป็น WebOS)

สิ่งนี้ต้องการความสำคัญในการออกแบบแอปพลิเคชันมากขึ้นโดยมุ่งเน้นไปที่เป้าหมายทางธุรกิจและไม่ยึดติดกับรูปแบบการใช้งานที่เชื่อมโยงกับสภาพแวดล้อมของแอปพลิเคชันก่อนหน้า นักพัฒนาที่ขาดเวลาหรือความชอบในการทำเช่นนี้จะหงุดหงิดกับสภาพแวดล้อมที่ใหม่กว่าซึ่งทำลายโมเดลจิตที่มีอยู่ นี่ไม่ใช่ความผิดของสภาพแวดล้อมใด ๆ เลยยิ่งไปกว่านั้นมันเป็นความผิดของภูเขาสำหรับพายุที่ไหลรอบมันมากกว่าผ่านมัน

ตัวอย่างเช่นสภาพแวดล้อมการพัฒนาบางอย่างเช่นHypercardและ Smalltalk มีแอปพลิเคชันและเครื่องมือในการพัฒนาร่วมกันในการตั้งค่าเดียว แนวคิดนี้ไม่ได้จับอะไรมากนอกส่วนขยายภาษาไปยังแอป (เช่นVBAในExcel , Lisp ใน AutoCAD ) นักพัฒนาซอฟต์แวร์ที่มาพร้อมกับโมเดลจิตที่สันนิษฐานว่ามีเครื่องมือการพัฒนาอยู่ในแอพดังนั้นจึงต้องเปลี่ยนโมเดลหรือ จำกัด ตัวเองให้อยู่ในสภาพแวดล้อมที่โมเดลของพวกเขาจะเป็นจริง

ดังนั้นเมื่อคุณเขียน:

นอกเหนือจากสิ่งยุ่ง ๆ อื่น ๆ ที่ฉันค้นพบแล้วฉันคิดว่าการพัฒนาแอพของเราสำหรับ Android จะไม่เกิดขึ้น

นั่นจะเป็นสิ่งที่ดีที่สุดสำหรับคุณในตอนนี้ ในทำนองเดียวกันฉันจะแนะนำให้คุณพยายามพอร์ตแอปพลิเคชันของคุณไปยังเว็บเนื่องจากปัญหาเดียวกันกับที่คุณรายงานกับ Android คุณจะพบในแอปพลิเคชันบนเว็บเช่นกัน (เช่นไม่มีการ "ยุติ") หรือตรงกันข้ามสักวันหนึ่งถ้าคุณทำพอร์ตแอปของคุณไปยังเว็บที่คุณอาจพบว่าการไหลของแอพลิเคชันเว็บอาจจะเป็นที่การแข่งขันที่ดีกว่าสำหรับ Android, และคุณสามารถทบทวนพอร์ต Android ในช่วงเวลานั้น

ฉันแค่ต้องการเพิ่มการแก้ไขที่นี่สำหรับผู้อ่านในอนาคตของหัวข้อนี้ ความแตกต่างกันนิดหน่อยนี้ทำให้ฉันเข้าใจไม่ได้นานดังนั้นฉันจึงต้องการให้แน่ใจว่าไม่มีใครทำผิดพลาดแบบเดียวกัน:

System.exit()ไม่ฆ่าแอปของคุณหากคุณมีมากกว่าหนึ่งกิจกรรมในกองซ้อน สิ่งที่เกิดขึ้นจริงก็คือกระบวนการถูกฆ่าและเริ่มต้นใหม่ทันทีด้วยกิจกรรมที่น้อยลงหนึ่งรายการบนสแต็ก นี่คือสิ่งที่เกิดขึ้นเมื่อแอปของคุณถูกฆ่าโดยกล่องโต้ตอบบังคับปิดหรือแม้กระทั่งเมื่อคุณพยายามที่จะฆ่ากระบวนการจาก DDMS นี่คือความจริงที่ไม่มีเอกสารทั้งหมดเพื่อความรู้ของฉัน

คำตอบสั้น ๆ คือถ้าคุณต้องการออกจากแอปพลิเคชันของคุณคุณต้องติดตามกิจกรรมทั้งหมดในสแต็กของคุณและfinish()ทั้งหมดของพวกเขาเมื่อผู้ใช้ต้องการออก (และไม่ไม่มีวิธีที่จะวนซ้ำผ่านสแต็กกิจกรรม ดังนั้นคุณต้องจัดการทั้งหมดด้วยตัวเอง) แม้สิ่งนี้จะไม่ได้ฆ่ากระบวนการหรือการอ้างอิงที่เป็นอันตรายใด ๆ ที่คุณอาจมี มันเสร็จสิ้นกิจกรรม นอกจากนี้ฉันไม่แน่ใจว่าProcess.killProcess(Process.myPid())ทำงานได้ดีขึ้นหรือไม่ ฉันยังไม่ได้ทดสอบ

หากในอีกทางหนึ่งมันก็โอเคสำหรับคุณที่จะมีกิจกรรมที่เหลืออยู่ในสแต็คของคุณมีวิธีอื่นที่ทำให้สิ่งที่ง่ายสุดสำหรับคุณ: Activity.moveTaskToBack(true)เพียงแค่พื้นหลังกระบวนการของคุณและแสดงหน้าจอที่บ้าน

คำตอบยาวเกี่ยวข้องกับคำอธิบายของปรัชญาที่อยู่เบื้องหลังพฤติกรรมนี้ ปรัชญาเกิดจากข้อสันนิษฐานหลายประการ:

1. ก่อนอื่นสิ่งนี้จะเกิดขึ้นเมื่อแอปของคุณอยู่เบื้องหน้าเท่านั้น หากอยู่ในพื้นหลังกระบวนการจะยุติได้ดี อย่างไรก็ตามหากอยู่ในเบื้องหน้า OS จะถือว่าผู้ใช้ต้องการทำสิ่งที่ตนทำอยู่ต่อไป (หากคุณพยายามที่จะฆ่ากระบวนการจาก DDMS คุณควรกดปุ่มโฮมก่อนแล้วจึงฆ่ามัน)
2. นอกจากนี้ยังอนุมานว่าแต่ละกิจกรรมนั้นเป็นอิสระจากกิจกรรมอื่น ๆ ทั้งหมด สิ่งนี้มักเป็นจริงเช่นในกรณีที่แอปของคุณเปิดใช้งานกิจกรรมเบราว์เซอร์ซึ่งแยกจากกันอย่างสิ้นเชิงและคุณไม่ได้เขียน กิจกรรมเบราว์เซอร์อาจสร้างหรือไม่สร้างขึ้นในงานเดียวกันทั้งนี้ขึ้นอยู่กับคุณสมบัติ
3. สันนิษฐานว่ากิจกรรมแต่ละอย่างของคุณพึ่งพาตนเองได้อย่างสมบูรณ์และสามารถถูกฆ่า / ฟื้นฟูได้ในเวลาอันสั้น (ฉันค่อนข้างไม่ชอบสมมติฐานนี้เนื่องจากแอพของฉันมีกิจกรรมมากมายที่ต้องอาศัยข้อมูลแคชจำนวนมากใหญ่เกินกว่าที่จะจัดลำดับได้อย่างมีประสิทธิภาพในช่วงonSaveInstanceStateแต่ Whaddya จะต้องทำอย่างไร) สำหรับแอป Android ที่เขียนดีที่สุดนี้ควรเป็นจริง เนื่องจากคุณไม่มีทางรู้ได้เลยว่าแอพของคุณจะถูกฆ่าในพื้นหลังเมื่อใด
4. ปัจจัยสุดท้ายไม่ได้เป็นข้อสันนิษฐานมากนัก แต่เป็นข้อ จำกัด ของระบบปฏิบัติการ: การ ฆ่าแอพอย่างชัดเจนเหมือนกับแอพที่หยุดทำงานและเช่นเดียวกับ Android ที่ฆ่าแอพเพื่อเรียกคืนหน่วยความจำ สิ่งนี้ถือเป็นจุดสูงสุดในการทำรัฐประหารของเรา: เนื่องจาก Android ไม่สามารถบอกได้ว่าแอพที่ออกมาหรือทำงานผิดพลาดหรือถูกฆ่าในพื้นหลังนั้นจะถือว่าผู้ใช้ต้องการส่งคืนที่ที่พวกเขาออกไปและ ActivityManager รีสตาร์ทกระบวนการ

เมื่อคุณคิดถึงมันสิ่งนี้เหมาะสำหรับแพลตฟอร์ม อย่างแรกนี่คือสิ่งที่เกิดขึ้นเมื่อกระบวนการถูกฆ่าในเบื้องหลังและผู้ใช้กลับมาสู่กระบวนการดังนั้นจึงต้องเริ่มต้นใหม่เมื่อปล่อยทิ้ง ประการที่สองนี่คือสิ่งที่จะเกิดขึ้นเมื่อแอปหยุดทำงานและแสดงกล่องโต้ตอบ Force Close ที่น่ากลัว

สมมติว่าฉันต้องการให้ผู้ใช้ของฉันสามารถถ่ายภาพและอัปโหลดได้ ฉันเริ่มกิจกรรมกล้องจากกิจกรรมของฉันและขอให้ส่งคืนรูปภาพ กล้องถูกผลักไปที่ด้านบนสุดของงานปัจจุบันของฉัน (แทนที่จะถูกสร้างในงานของตัวเอง) หากกล้องมีข้อผิดพลาดและขัดข้องควรส่งผลให้แอปทั้งหมดขัดข้องหรือไม่ จากมุมมองของผู้ใช้กล้องเท่านั้นที่ล้มเหลวและพวกเขาควรจะกลับไปที่กิจกรรมก่อนหน้าของพวกเขา ดังนั้นเพียงแค่รีสตาร์ทกระบวนการด้วยกิจกรรมเดียวกันทั้งหมดในสแต็กลบด้วยกล้อง เนื่องจากกิจกรรมของคุณควรได้รับการออกแบบเพื่อให้สามารถฆ่าและเรียกคืนได้เมื่อสวมหมวกนี่ไม่น่าจะมีปัญหา น่าเสียดายที่แอพบางตัวนั้นไม่สามารถออกแบบได้ดังนั้นจึงเป็นเช่นนั้นปัญหาสำหรับพวกเราหลายคนไม่ว่า Romain Guy หรือคนอื่นจะบอกอะไรคุณ ดังนั้นเราต้องใช้วิธีแก้ปัญหา

ดังนั้นคำแนะนำการปิดของฉัน:

• อย่าพยายามฆ่ากระบวนการ ทั้งโทรในทุกกิจกรรมหรือโทรfinish()moveTaskToBack(true)
• หากกระบวนการของคุณล้มเหลวหรือถูกฆ่าและเช่นเดียวกับฉันคุณต้องการข้อมูลที่อยู่ในหน่วยความจำซึ่งตอนนี้หายไปคุณจะต้องกลับไปที่กิจกรรมรูท ในการทำเช่นนี้คุณควรโทรหาstartActivity()ด้วยเจตนาที่มีการIntent.FLAG_ACTIVITY_CLEAR_TOPตั้งค่าสถานะ
• หากคุณต้องการฆ่าแอปของคุณจากเปอร์สเปคทีฟ Eclipse DDMS มันจะดีกว่าถ้าไม่อยู่ในเบื้องหน้าไม่เช่นนั้นจะรีสตาร์ทตัวเอง คุณควรกดปุ่มโฮมก่อนแล้วจึงฆ่ากระบวนการ

แอปพลิเคชันทั้งหมดของฉันมีปุ่มออกจาก ... และฉันมักจะได้รับความคิดเห็นในเชิงบวกจากผู้ใช้เพราะมัน ฉันไม่สนใจว่าแพลตฟอร์มนั้นได้รับการออกแบบในแบบที่แอพพลิเคชั่นไม่ควรต้องการหรือไม่ การพูดว่า "อย่าทำให้พวกมันอยู่ตรงนั้น" เป็นเรื่องไร้สาระ หากผู้ใช้ต้องการออกจาก ... ฉันให้สิทธิ์การเข้าถึงแก่พวกเขาในการทำเช่นนั้น ฉันไม่คิดว่ามันจะช่วยลดการทำงานของ Android เลยและดูเหมือนจะเป็นแนวปฏิบัติที่ดี ฉันเข้าใจวงจรชีวิต ... และการสังเกตของฉันก็คือว่า Android นั้นทำงานได้ไม่ดีในการจัดการกับมัน .... และนั่นเป็นข้อเท็จจริงพื้นฐาน

หยุดคิดถึงแอปพลิเคชันของคุณเป็นแอปพลิเคชันแบบเสาหิน เป็นชุดของหน้าจอ UI ที่ผู้ใช้สามารถโต้ตอบกับ "แอปพลิเคชัน" ของคุณและ "ฟังก์ชั่น" ที่จัดให้ผ่านบริการ Android

ไม่ทราบว่าแอปลึกลับของคุณ "ทำ" ไม่สำคัญจริงๆ สมมติว่ามันเป็นช่องทางในอินทราเน็ตขององค์กรที่มีความปลอดภัยสูงดำเนินการตรวจสอบหรือโต้ตอบและเข้าสู่ระบบจนกว่าผู้ใช้จะ "ออกจากแอปพลิเคชัน" เนื่องจากแผนกไอทีของคุณสั่งการผู้ใช้จะต้องตระหนักถึงอย่างมากเมื่อพวกเขาอยู่ในหรือนอกอินทราเน็ต ดังนั้นความคิดของคุณจึงเป็นเรื่องสำคัญที่ผู้ใช้จะต้อง "ออกจาก"

มันง่ายมาก สร้างบริการที่แจ้งเตือนอย่างต่อเนื่องในแถบการแจ้งเตือนว่า "ฉันอยู่ในอินทราเน็ตหรือฉันกำลังทำงานอยู่" ให้บริการนั้นทำหน้าที่ทั้งหมดที่คุณต้องการสำหรับแอปพลิเคชันของคุณ มีกิจกรรมที่เชื่อมโยงกับบริการนั้นเพื่อให้ผู้ใช้ของคุณเข้าถึงบิตของ UI ที่พวกเขาต้องการเพื่อโต้ตอบกับ "แอปพลิเคชัน" ของคุณ และมีเมนู Android -> ออกจากปุ่ม (หรือออกจากระบบหรืออะไรก็ตาม) ที่บอกว่าบริการเลิกแล้วปิดกิจกรรมเอง

นี่คือสำหรับทุกเจตนารมณ์และวัตถุประสงค์ตรงตามที่คุณพูดในสิ่งที่คุณต้องการ ทำตามวิธี Android ดูที่ Google Talk หรือ Google Maps การนำทางตัวอย่างของ "ทางออก" นี้อาจเป็นไปได้ ข้อแตกต่างเพียงอย่างเดียวคือการกดปุ่มย้อนกลับออกจากกิจกรรมของคุณอาจทำให้กระบวนการ UNIX ของคุณอยู่ในสถานะรอในกรณีที่ผู้ใช้ต้องการที่จะฟื้นฟูแอปพลิเคชันของคุณ นี่ไม่ต่างจากระบบปฏิบัติการที่ทันสมัยซึ่งแคชไฟล์ที่เพิ่งเข้าถึงในหน่วยความจำ หลังจากที่คุณออกจากโปรแกรม windows ทรัพยากรที่เป็นไปได้ส่วนใหญ่ที่ต้องการยังคงอยู่ในหน่วยความจำรอให้ถูกแทนที่ด้วยทรัพยากรอื่น ๆ เนื่องจากโหลดในตอนนี้ซึ่งไม่จำเป็นต้องใช้อีกต่อไป Android เป็นสิ่งเดียวกัน

ฉันไม่เห็นปัญหาของคุณจริงๆ

นี่คือการสนทนาที่น่าสนใจและลึกซึ้งกับผู้เชี่ยวชาญจำนวนมากที่ให้การสนับสนุน ฉันรู้สึกว่าโพสต์นี้ควรวนกลับจากภายในเว็บไซต์หลักของการพัฒนา Android เพราะมันหมุนรอบหนึ่งในการออกแบบหลักของ Android OS

ฉันต้องการเพิ่มสองเซ็นต์ของฉันที่นี่

จนถึงตอนนี้ฉันประทับใจกับวิธีการจัดการวงจรชีวิตของ Android ซึ่งนำแนวคิดของประสบการณ์การใช้เว็บเหมือนแอพทั่วไป

ต้องบอกว่าฉันยังเชื่อว่าควรมีQuitปุ่ม ทำไม? ... ไม่ใช่สำหรับฉันหรือ Ted หรือผู้เชี่ยวชาญด้านเทคโนโลยีใด ๆ ที่นี่ แต่เพื่อจุดประสงค์เดียวในการตอบสนองความต้องการของผู้ใช้

แม้ว่าฉันจะไม่ใช่แฟนตัวยงของ Windows แต่พวกเขากลับใช้แนวคิดที่ผู้ใช้ส่วนใหญ่คุ้นเคย (ปุ่ม X) ... "ฉันต้องการเลิกใช้วิดเจ็ตเมื่อ 'ฉัน' ต้องการ

นั่นไม่ได้หมายความว่าใครบางคน (OS, นักพัฒนา?) จะดูแลมันตามดุลยพินิจของเขา / เธอ ... มันหมายถึง "ปุ่ม Red X ของฉันที่ฉันคุ้นเคย" อยู่ที่ไหน การกระทำของฉันควรคล้ายคลึงกับ 'วางสายเมื่อกดปุ่ม', 'ปิดอุปกรณ์โดยการกดปุ่ม' และต่อ ๆ ไปเรื่อย ๆ ... มันเป็นการรับรู้ มันนำมาซึ่งความพึงพอใจต่อการกระทำของฉันที่บรรลุตามวัตถุประสงค์

แม้ว่าผู้พัฒนาสามารถหลอกลวงพฤติกรรมนี้โดยใช้คำแนะนำที่ให้ไว้ที่นี่การรับรู้ยังคงอยู่นั่นคือแอปพลิเคชันควรหยุดทำงานอย่างสมบูรณ์ (ตอนนี้) โดยแหล่งข้อมูลอิสระที่เชื่อถือได้และเป็นกลาง (OS) ตามความต้องการจากผู้ใช้

คุณสามารถออกจากการอย่างใดอย่างหนึ่งโดยการกดBackปุ่มหรือโทรในของคุณfinish() Activityเพียงโทรfinish()จาก a MenuItemหากคุณต้องการฆ่ามันอย่างชัดเจน

Romain ไม่ได้บอกว่าไม่สามารถทำได้เพียงเพราะมันไม่มีจุดหมาย - ผู้ใช้ไม่จำเป็นต้องใส่ใจกับการเลิกหรือบันทึกงานของพวกเขาหรืออะไรก็ตามเนื่องจากวงจรชีวิตของแอปพลิเคชันสนับสนุนให้คุณเขียนซอฟต์แวร์อัจฉริยะที่บันทึกและอัตโนมัติ คืนสถานะของมันไม่ว่าจะเกิดอะไรขึ้น

การถกเถียงครั้งนี้ทำให้เกิดคำถามที่ว่าผู้พัฒนารู้จักดีที่สุดหรือผู้ใช้รู้ดีที่สุดหรือไม่ นักออกแบบมืออาชีพในทุกด้านของปัจจัยมนุษย์ต่อสู้กับสิ่งนี้ทุกวัน

Ted ได้ชี้ให้เห็นว่าหนึ่งในแอพที่ดาวน์โหลดมากที่สุดใน Market คือ 'App Killer' ผู้คนจะได้รับเซโรโทนินเพิ่มขึ้นเล็กน้อยเมื่อพวกเขาออกจากแอปพลิเคชัน พวกมันคุ้นเคยกับเดสก์ท็อป / แล็ปท็อป มันทำให้สิ่งต่าง ๆ เคลื่อนไหวเร็ว มันทำให้โปรเซสเซอร์เย็นและเปิดพัดลม มันใช้พลังงานน้อยลง

เมื่อคุณพิจารณาว่าอุปกรณ์พกพานั้นมีขนาดเล็กกว่าเรือมากคุณสามารถชื่นชมแรงจูงใจของพวกเขาในการ 'โยนลงเรือสิ่งที่คุณไม่ต้องการอีกต่อไป' ตอนนี้นักพัฒนาของ Android ให้เหตุผลว่าระบบปฏิบัติการรู้ดีที่สุดและการเลิกใช้แอพนั้นเป็นของโบราณ ฉันสนับสนุนอย่างสุดซึ้งนี้

อย่างไรก็ตามฉันเชื่อว่าคุณไม่ควรทำให้ผู้ใช้ผิดหวังแม้ว่าความยุ่งยากนั้นจะเกิดจากความไม่รู้ของตัวเอง ด้วยเหตุนี้ฉันจึงสรุปได้ว่าการมีตัวเลือก 'ออก' คือการออกแบบที่ดีแม้ว่าส่วนใหญ่จะเป็นปุ่มหลอกที่ไม่ได้ทำอะไรมากไปกว่าการปิดมุมมอง

เท็ดสิ่งที่คุณพยายามจะทำให้สำเร็จนั้นอาจจะเป็นไปได้ไม่ใช่แค่ว่าคุณกำลังคิดถึงมันอยู่ในตอนนี้

ฉันแนะนำให้คุณอ่านข้อมูลเกี่ยวกับกิจกรรมและบริการ หยุดใช้คำว่า "แอพ" และเริ่มอ้างถึงส่วนประกอบเช่นกิจกรรมบริการ ฉันคิดว่าคุณต้องเรียนรู้เพิ่มเติมเกี่ยวกับแพลตฟอร์ม Android; เป็นการเปลี่ยนความคิดจากแอปพีซีมาตรฐาน ความจริงที่ว่าไม่มีการโพสต์ของคุณมีคำว่า "กิจกรรม" (สั้นจากใบเสนอราคาคำถามที่พบบ่อยไม่ใช่คำพูดของคุณ) ในพวกเขาบอกฉันว่าคุณต้องอ่านเพิ่มเติม

บล็อกโพสต์เมื่อจะรวมปุ่มออกใน Android Apps (คำแนะนำ: ไม่เคย)อธิบายว่ามันไกลไกลดีกว่าที่ฉันสามารถทำได้ ฉันหวังว่านักพัฒนา Android ทุกคนจะอ่านมันแล้ว

ข้อความที่ตัดตอนมา:

จากประสบการณ์ของฉันสิ่งที่ [ผู้ใช้] ต้องการคือ: วิธีการที่ชัดเจนในการรับประกันว่าแอปจะหยุดการใช้ทรัพยากร (แบตเตอรี่, รอบการทำงานของ CPU, การถ่ายโอนข้อมูล ฯลฯ )

ผู้ใช้หลายคนรับรู้ว่าปุ่มออกจะใช้ข้อกำหนดนี้และขอให้เพิ่ม นักพัฒนาที่ต้องการสร้างความพอใจให้กับผู้ใช้ของพวกเขาควรเพิ่มอีกหนึ่งรายการ หลังจากนั้นไม่นานทั้งคู่ก็ล้มเหลว

• Activity.finish()ในกรณีส่วนใหญ่ปุ่มออกก็เรียก นี่คือว่าเทียบเท่ากับการกดปุ่มปุ่มย้อนกลับ เผง บริการยังคงทำงานต่อไปและการสำรวจยังคงเกิดขึ้น ผู้ใช้อาจคิดว่าพวกเขาฆ่าแอพแล้วแต่พวกเขาไม่ได้และในไม่ช้าพวกเขาก็จะยิ่งรำคาญมากขึ้น
• พฤติกรรมการออกตอนนี้ไม่ชัดเจน ปุ่มออกของคุณควรปิดกิจกรรมหรือควรหยุดบริการที่เกี่ยวข้องผู้รับและสัญญาณเตือนทั้งหมดด้วยหรือไม่ ควรBackทำอย่างไร? จะเกิดอะไรขึ้นถ้าพวกเขาตีHomeแทน? จะเกิดอะไรขึ้นถ้าแอปของคุณมีวิดเจ็ต ปุ่มออกควรหยุดการอัปเดตนั้นด้วยหรือไม่

วิธีแก้ปัญหาคือทำให้ปุ่มย้อนกลับทำงานตามที่คุณคาดหวังว่าปุ่มออกจะเป็น ยังดีกว่าเพียงหยุดการใช้ทรัพยากรเมื่อใดก็ตามที่แอปไม่สามารถมองเห็นได้

ไปข้างหน้าและอ่านบทความทั้งหมด

คำตอบ: (Romain Guy): ผู้ใช้ไม่ได้ระบบจะจัดการสิ่งนี้โดยอัตโนมัติ นั่นคือสิ่งที่วงจรชีวิตของกิจกรรม (โดยเฉพาะ onPause / onStop / onDestroy) มีไว้สำหรับ ไม่ว่าคุณจะทำอะไรอย่าใส่ปุ่มแอปพลิเคชัน "ออกจาก" หรือ "ออก" มันไม่มีประโยชน์กับแอปพลิเคชันของ Android นี่เป็นสิ่งที่ตรงกันข้ามกับวิธีการทำงานของแอปพลิเคชันหลัก

1: การออกจากแอปพลิเคชันทั้งหมดโดยทั่วไปอาจไม่มีการควบคุม แต่มันก็ไม่ไร้ประโยชน์ ถ้า windows ไม่มีตัวเลือก exit ระบบจะด็อกกี้ช้าเนื่องจากหน่วยความจำเต็มและระบบปฏิบัติการต้องเดาว่าคุณใช้โปรแกรมใด ฉันไม่สนใจสิ่งที่ Romain Guy หรือ Larry Page และ Sergey Brin พูด - นี่เป็นข้อเท็จจริงที่ไม่อาจปฏิเสธได้: ระบบทำงานช้าลงเมื่อพวกเขาต้องฆ่างานเพื่อให้ได้หน่วยความจำก่อนที่จะเปิดตัวแอปใหม่ คุณแค่บอกฉันไม่ได้ว่ามันใช้เวลาไม่นานในการฆ่าแอพ! แม้แต่แสงจากดวงดาวไกลใช้เวลาในการ ... มีคือการใช้งานบางอย่างในการช่วยให้ผู้ใช้แอพพลิเคใกล้ได้อย่างเต็มที่

2: ตรงกันข้ามกับวิธีการทำงานของแอปพลิเคชันหลัก นั่นหมายความว่าไง? เมื่อตอนนี้ฉันใช้แอพเสร็จแล้วมันไม่ทำงานอีกต่อไป ... มันกำลังรอที่จะถูกระบบปฏิบัติการฆ่าเมื่อจำเป็นต้องใช้หน่วยความจำ

โดยสรุปมีความแตกต่างที่ชัดเจนระหว่างการย่อและการออก เราปล่อยไขควงไว้ในสกรูทุกตัวหรือไม่? หรือกุญแจในทุกประตู? เราปล่อยให้เครื่องใช้ไฟฟ้าทั้งหมดของเราสูงจนเครื่องเบรกเกอร์ระเบิดและเราจำเป็นต้องเปิดเครื่องใช้อื่นหรือไม่? เราปล่อยให้เครื่องล้างจานเต็มไปด้วยอาหารและใช้เวลาเพียงพอในแต่ละครั้งเพื่อให้มีที่ว่างสำหรับสิ่งสกปรกใหม่หรือไม่? พวกเราปล่อยให้รถทุกคันวิ่งไปตามทางหรือไม่ -

หากผู้ใช้ต้องการย่อขนาดแอปสิ่งที่ดีที่สุดคือการย่อให้เล็กสุด หากผู้ใช้ต้องการออกจากแอปหมายความว่าเป็นการดีที่สุดที่จะออก

มันขมวดคิ้วหรือเปล่า? นั่นเป็นมุมมองของ Android - พวกเขาขมวดคิ้วอยู่กับมัน และนักพัฒนามือใหม่ Android หลายคนก็ขมวดคิ้วในเรื่องนี้

แต่เมื่อมันลงมามีการเข้ารหัสที่ดีและการเข้ารหัสที่ไม่ดี มีโมเดลโฟลว์ของโปรแกรมที่ดีและมีโมเดลโฟลว์ของโปรแกรมที่ไม่ดี

ออกจากโปรแกรมในหน่วยความจำเมื่อผู้ใช้รู้ว่าพวกเขาจะทำกับพวกเขาก็ไม่ได้เป็นโปรแกรมที่ดี มันทำหน้าที่อย่างไม่มีวัตถุประสงค์ใด ๆ และมันช้าลงเมื่อเปิดตัวแอพใหม่หรือเมื่อเรียกใช้แอพจัดสรรหน่วยความจำเพิ่มเติม

มันเหมือนกับรถของคุณ: มีหลายครั้งที่คุณปล่อยให้มันวิ่งเหมือนหยุดที่ไฟหยุดหรืออาจจะเป็นอาหารจานด่วนขับผ่านหรือหยุดที่ตู้เอทีเอ็ม แต่มีสถานการณ์อื่น ๆ ที่คุณต้องการปิดมัน - เช่นเมื่อคุณไปทำงานหรือร้านขายของชำหรือแม้แต่ที่บ้าน

ในทำนองเดียวกันถ้าคุณกำลังเล่นเกมและโทรศัพท์ดังขึ้นใช่ หยุดเกมชั่วคราวและเล่นต่อไป แต่ถ้าผู้ใช้เล่นเกมเป็นระยะเวลาหนึ่งให้ปล่อยให้พวกเขาออกไป

ปุ่มออกในบางแอพพลิเคชั่นควรอยู่ข้างหน้ามากกว่าแอพพลิเคชั่นอื่น ๆ ตัวอย่างเช่นเกมหรือโปรแกรมที่ผู้ใช้มีแนวโน้มที่จะต้องการออกอย่างสมบูรณ์ควรมีทางออกที่ชัดเจน โปรแกรมอื่น ๆ เช่นบางทีโปรแกรมอีเมลที่ออกจากโปรแกรมนั้นเป็นความต้องการที่ไม่น่าจะเกิดขึ้น (เพื่อให้สามารถตรวจสอบอีเมลได้) - โปรแกรมเหล่านี้ไม่ควรเสียพื้นที่หน้าจออินพุตควบคุมที่สำคัญด้วยตัวเลือกออก แต่สำหรับโปรแกรมที่ดี ควรมีตัวเลือกออก จะเป็นอย่างไรถ้ามีคนตัดสินใจว่าพวกเขาไม่ต้องการให้โปรแกรมจดหมายของพวกเขาพยายามตรวจสอบอีเมลเมื่อพวกเขาอยู่ในพื้นที่ครอบคลุมที่ไม่ดีหรืออาจจะอยู่ในสาย Skype หรืออะไรก็ตาม ปล่อยให้พวกเขาออกจากโปรแกรมอีเมลหากพวกเขาต้องการ!

การระงับและออกจากงานเป็นภารกิจที่สำคัญสองประการและไม่ได้ทำหน้าที่ของอีกฝ่ายให้สำเร็จ

ฉันคิดว่าประเด็นคือไม่จำเป็นต้องออกจากแอพเว้นแต่คุณจะมีซอฟต์แวร์บั๊ก Android ออกจากแอปเมื่อผู้ใช้ไม่ได้ใช้งานและอุปกรณ์ต้องการหน่วยความจำเพิ่มเติม หากคุณมีแอพที่จำเป็นต้องเปิดใช้งานบริการในเบื้องหลังคุณอาจต้องการวิธีปิดบริการ

ตัวอย่างเช่น Google Listen เล่นพอดคาสต์ต่อไปเมื่อไม่เห็นแอป แต่มีปุ่มหยุดชั่วคราวเพื่อปิดพอดคาสต์เสมอเมื่อผู้ใช้เสร็จแล้ว หากฉันจำได้ถูกต้องฟังแม้กระทั่งวางทางลัดในแถบการแจ้งเตือนเพื่อให้คุณสามารถไปที่ปุ่มหยุดชั่วคราวได้อย่างรวดเร็ว อีกตัวอย่างหนึ่งคือแอปอย่างแอพทวิตเตอร์ที่มีการสำรวจบริการบนอินเทอร์เน็ตอยู่ตลอดเวลา แอพประเภทนี้ควรอนุญาตให้ผู้ใช้เลือกความถี่ในการสำรวจความคิดเห็นของเซิร์ฟเวอร์หรือไม่ว่าจะโพลในกระทู้เบื้องหลัง

หากคุณจำเป็นต้องมีรหัสที่ทำงานเมื่อออกคุณสามารถแทนที่ onPause (), onStop () หรือ onDestroy () ตามความเหมาะสม http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle

หากคุณไม่สามารถเข้าใจวิธีที่จะทำให้ข้อมูล / การเชื่อมต่อของคุณ (และ "แอปพลิเคชัน" ของคุณ) ขัดขืนคุณจะไม่สามารถทำสิ่งที่คุณต้องการใน Android ได้

ผู้ที่ดาวน์โหลด App Killers ตัวน้อยเหล่านี้มักจะพบว่าพวกเขาไม่ได้ช่วยยืดอายุการใช้งานแบตเตอรีหรือการใช้หน่วยความจำ แต่ขัดขวางระบบปฏิบัติการจากการจัดการหน่วยความจำอย่างมีประสิทธิภาพ ...

http://android-developers.blogspot.com/2010/04/multitasking-android-way.html

ฉันจะพิจารณาอ่าน"การพัฒนาแอปพลิเคชั่นไร้สาย Android"เผยแพร่โดย Addison-Wesley ฉันเพิ่งทำเสร็จแล้วและมันก็ละเอียดมาก

ดูเหมือนว่าคุณมีความเข้าใจผิดพื้นฐานเกี่ยวกับแพลตฟอร์ม Android ตอนแรกฉันก็รู้สึกผิดหวังเล็กน้อยกับวงจรชีวิตแอพพลิเคชั่นของแอพ Android แต่หลังจากทำความเข้าใจมากขึ้นฉันก็สนุกกับวิธีนี้มากขึ้น หนังสือเล่มนี้จะตอบทุกคำถามของคุณและอีกมากมาย เป็นแหล่งข้อมูลที่ดีที่สุดที่ฉันพบสำหรับนักพัฒนา Android ใหม่

นอกจากนี้ฉันคิดว่าคุณต้องปล่อยพอร์ต line-for-line ของแอพที่มีอยู่ เพื่อที่จะพอร์ตแอปพลิเคชันของคุณไปยังแพลตฟอร์ม Android การออกแบบแอพพลิเคชั่นบางอย่างกำลังจะเปลี่ยนไป วงจรชีวิตแอปพลิเคชันที่ใช้มีความจำเป็นเนื่องจากอุปกรณ์มือถือมีทรัพยากรที่ จำกัด มากเมื่อเทียบกับระบบเดสก์ท็อปและอนุญาตให้อุปกรณ์ Android รันแอปพลิเคชันหลายอย่างตามลำดับและตระหนักถึงทรัพยากร ศึกษาเพิ่มเติมเกี่ยวกับแพลตฟอร์มและฉันคิดว่าคุณจะรู้ว่าสิ่งที่คุณต้องการจะทำมีความเป็นไปได้ทั้งหมด ขอให้โชคดี

อย่างไรก็ตามฉันไม่มีส่วนเกี่ยวข้องกับแอดดิสัน - เวสลีย์หรือบุคคลหรือองค์กรใด ๆ ที่เกี่ยวข้องกับหนังสือเล่มนี้ หลังจากอ่านโพสต์ของฉันอีกครั้งฉันรู้สึกว่าฉันออกแฟนพันธุ์แท้เล็กน้อย ฉันแค่สนุกกับมันจริงๆและพบว่ามันมีประโยชน์มาก :)

เกือบ 99% ของเวลาไม่จำเป็นสำหรับแอปพลิเคชัน Android ที่จะควบคุมวงจรชีวิตของตัวเอง ใช้เวลาส่วนใหญ่ในการวางแผนหรือออกแบบแอพพลิเคชั่นให้ดีขึ้น ตัวอย่างเช่นแทนที่จะสร้างบริการภายใน (ไม่ส่งออก) เพื่อจัดการการดาวน์โหลด ฯลฯ หรือออกแบบการกระทำและงานรอบเวิร์กโฟลว์ผู้ใช้

แต่ที่ถูกกล่าวว่ามีที่ไหนจะมีวิธี Android จัดเตรียม - ผ่านคลาส android.os.Process ซึ่งเป็น API ที่ดีกว่า Java เพื่อควบคุมกระบวนการพื้นฐาน และแตกต่างจาก Java มันไม่ได้ปฏิบัติต่อนักพัฒนาเช่นปัญญาอ่อนโดยซ่อนมันไว้ข้างหลังโทร java.lang.System.exit () ง่าย ๆ

ดังนั้นคุณจะขอให้แอปพลิเคชันของคุณฆ่าตัวตายใน Android ได้อย่างไร? เคล็ดลับง่าย ๆ :

สร้างคลาสแอปพลิเคชัน Android ของคุณเองโดยสืบทอดจากคลาส android.app.Application มาตรฐาน (อย่าลืมประกาศในไฟล์ AndroidManifest.xml)

แทนที่เมธอด onCreate () และเก็บ ID กระบวนการที่เริ่มต้นแอปพลิเคชันของคุณ:

this.pid = android.os.Process.myPid(); // Save for later use.

ตอนนี้เพื่อฆ่าแอปพลิเคชันของคุณให้ใช้วิธีการ kill ():

android.os.Process.sendSignal(pid, android.os.Process.SIGNAL_KILL);

ตอนนี้เมื่อใดก็ตามที่คุณต้องการให้แอปของคุณฆ่าตัวตายให้พิมพ์บริบทของแอปพลิเคชันแล้วโทรหาวิธีการฆ่าของคุณ!

((MySuicidalApp) context.getApplicationContext()).kill()

เพียงจำไว้ว่าเนื่องจากนโยบายการจัดการกระบวนการใน Android ที่เกี่ยวข้องกับบริการโดยเฉพาะ Android อาจเลือกที่จะรีสตาร์ทบริการของคุณ (ดูที่คุณไม่ควรใช้ task killer บน Android )

เมื่อฉันคิดแอปพลิเคชันใน Android ฉันเห็นด้วยวิธีนี้:

• คุณกำลังทำงานกับแอปพลิเคชันของคุณ
• โทรศัพท์ดัง
• คุณรับสาย
• เมื่อสิ้นสุดการโทรคุณจะกลับมาที่แอปพลิเคชันของคุณในที่เดียวกับที่คุณอยู่

ในการทำเช่นนั้นคุณจะต้องใช้Backปุ่มหรือHomeปุ่มในโทรศัพท์ของคุณเท่านั้น (โดยการกดสั้นหรือยาว) และแถบการแจ้งเตือน

เมื่อฉันออกจากแอปพลิเคชันของฉันฉันจะใช้Backปุ่มจนกว่าฉันจะออกจากมันหรือHomeปุ่ม

ฉันคิดว่าแอพพลิเคชั่นส่วนใหญ่รู้สึกได้ แต่ถ้าฉันต้องการเซสชั่นหรือการเชื่อมต่อบางอย่างฉันทำให้ผู้ใช้ชัดเจนด้วยปุ่มเข้าสู่ระบบ / ออกจากระบบและการแจ้งเตือน (แถบชื่อเรื่องหรืออย่างอื่น) นี่เป็นสไตล์ที่ค่อนข้างแตกต่างจากแอพพลิเคชั่นสไตล์ "ทางออก" อย่างแท้จริง

บนพีซีคุณมีเดสก์ท็อปหลาย GUI และบน Android คุณเห็นได้ชัดว่ามีหลายงาน แต่คุณจะแสดงแอพได้ครั้งละหนึ่งแอปเท่านั้น (ฉันไม่ได้พิจารณาวิดเจ็ตที่นี่ ^^) และบนโทรศัพท์มือถือคุณสามารถมีการแจ้งเตือนบางสิ่งที่สำคัญกว่าสิ่งที่คุณทำ

ดังนั้นแนวคิดทั้งหมดของแอปพลิเคชันจึงขึ้นอยู่กับสิ่งที่แตกต่างกันที่ "เข้าสู่แอปพลิเคชัน - งาน - ออกจากแอปพลิเคชัน"

Hmmmm ...

ฉันคิดว่าคุณไม่เห็นแอพ Android ที่ถูกต้อง คุณสามารถทำสิ่งที่ต้องการได้อย่างง่ายดาย:

• ทำกิจกรรมแอพบันทึก / กู้คืนสถานะเหมือนได้รับการสนับสนุนในเอกสารนักพัฒนา livecycle

• หากจำเป็นต้องเข้าสู่ระบบบางอย่างในขั้นตอนการกู้คืน (ไม่มีข้อมูลการเข้าสู่ระบบ / เซสชัน) ให้ทำ

• ในที่สุดก็เพิ่มปุ่ม / เมนู / หมดเวลาในกรณีที่คุณจะทำfinish()โดยไม่ต้องบันทึกการเข้าสู่ระบบและข้อมูลเซสชั่นอื่น ๆ ทำให้สิ้นเซสชั่นแอปโดยปริยาย: ดังนั้นหากแอปเริ่ม / นำไปข้างหน้าอีกครั้งก็จะเริ่มเซสชั่นใหม่

ด้วยวิธีนี้คุณไม่สนใจว่าแอพนั้นจะถูกลบออกจากหน่วยความจำจริงหรือไม่

หากคุณต้องการที่จะลบมันออกจากหน่วยความจำ (นี่คือกำลังใจและ BTW สำหรับวัตถุประสงค์อะไร?) คุณสามารถฆ่ามันตามเงื่อนไขในตอนท้ายของonDestroy()ด้วยjava.lang.System.exit(0)(หรืออาจrestartPackage(..)?) แน่นอนว่าทำได้เฉพาะในกรณีที่คุณต้องการ "จบแอปจริงๆ" เพราะonDestroy()เป็นส่วนหนึ่งของวงจรชีวิตปกติของกิจกรรมและไม่ใช่แอปที่สิ้นสุดเลย

ในฐานะที่เป็นแอปพลิเคชันในบริบท Android เป็นเพียงกิจกรรมที่เกี่ยวข้องอย่างคลุมเครือการออกจากแอปพลิเคชันไม่สมเหตุสมผลนัก คุณสามารถเสร็จสิ้น () กิจกรรมและมุมมองของกิจกรรมก่อนหน้าในสแต็กกิจกรรมจะถูกวาด

ฉันเห็นด้วยกับเท็ด ฉันเข้าใจว่าการออกจากแอปพลิเคชันไม่ใช่ "วิธี Android" แต่ดูเหมือนจะไม่ถูกกีดกัน ต่อไปนี้เป็นเหตุผลสามประการที่คุณอาจต้องการออกจากแอปพลิเคชันจริง (ไม่ใช่เฉพาะกิจกรรม):

1. ผู้ใช้อาจต้องการควบคุมบางแอปที่ถูกฆ่าในกรณีที่หน่วยความจำเหลือน้อย หากแอปที่สำคัญกำลังทำงานอยู่ในพื้นหลังคุณอาจต้องการออกจากแอพ B เมื่อคุณทำเสร็จแล้วเพื่อไม่ให้แอป A ไม่ถูกฆ่าโดยระบบปฏิบัติการ

2. หากแอปพลิเคชันของคุณมีแคชข้อมูลที่ละเอียดอ่อนในหน่วยความจำคุณอาจต้องการฆ่าแอปเพื่อให้แอปไวรัส / เวิร์ม / โกงไม่สามารถเข้าถึงได้ ฉันรู้ว่ารูปแบบความปลอดภัยควรจะป้องกันสิ่งนั้น แต่ในกรณี ...

3. หากแอปพลิเคชันของคุณใช้ทรัพยากร (เช่นเครือข่าย, CPU, เซ็นเซอร์ ฯลฯ ) ที่อาจส่งผลเสียต่อโทรศัพท์วิธีหนึ่งที่จะทำให้แน่ใจว่าทรัพยากรเหล่านั้นว่างแล้วคือออกจากแอปพลิเคชัน ฉันเข้าใจว่าแอพที่ทำงานได้ดีควรเพิ่มทรัพยากรเมื่อไม่จำเป็น แต่อีกครั้งการออกจากแอปพลิเคชันดูเหมือนจะเป็นวิธีที่สมเหตุสมผลในการรับรองว่า

เคอร์เนล Linux มีคุณสมบัติที่ชื่อว่าOut-of-memory killer (ดังกล่าวข้างต้นนโยบายสามารถกำหนดค่าได้ในระดับ userspace และ kernel ไม่เหมาะสมที่สุด แต่ไม่จำเป็นเลย)

และมันถูกใช้อย่างหนักโดย Android:

• OOM killer ไม่ได้มีไว้สำหรับ userspace

• Android Notes (OOM Killer Info - ที่ซึ่งคุณสามารถกำหนดค่าคุณสมบัติ OOM บน Android)

• การย้าย Android บนเป้าหมายจริง

แอพ userspace บางตัวพร้อมให้ความช่วยเหลือกับแอพ kill เหล่านี้ตัวอย่างเช่น

• Autokiller / การกำหนดค่า killer task ภายในของ Android

ดูเหมือนว่าคุณจะพบคำตอบที่คุณต้องการในคำสั่ง finish () การดำเนินการนี้จะไม่ลบแอปของคุณออกจากหน่วยความจำ แต่ Android จะทำเช่นนั้นเมื่อใดก็ตามที่ต้องการทรัพยากรดังนั้นจึงไม่สร้างความแตกต่างใด ๆ ที่คุณจะไม่ทำอย่างชัดเจน

ฉันจะเพิ่มเฉพาะเพื่อให้บรรลุผลเต็มรูปแบบที่โดยปกติแล้วแอปพลิเคชันจะออกคุณจะต้องการรีเซ็ตสถานะของแอพให้เป็นสถานะปกติในเวลาที่มันถูกเรียกใช้ครั้งแรกหลังจากการบู๊ตอุปกรณ์ก่อนหน้านี้ เพื่อโทรเสร็จสิ้น () ในกิจกรรมทั้งหมดของคุณ ด้วยวิธีนี้หากผู้ใช้เลือกแอปของคุณอีกครั้งแอปจะปรากฏเป็น "สด" โดยไม่มีสถานะใด ๆ ค้างอยู่จากจุดก่อนที่จะมีการออก "จำลอง"

หากมีการกระทำพิเศษที่ควรเกิดขึ้นเมื่อ "ออก" เช่นบันทึกงานของผู้ใช้หรืออะไรก็ตามคุณสามารถดำเนินการได้ก่อนส่วนการเริ่มต้นใหม่ของรูทีนด้านบนอีกครั้ง

วิธีนี้ช่วยให้คุณบรรลุเป้าหมายของการมีคำสั่ง "exit" โดยไม่ละเมิดปรัชญาของ Android ในการปล่อยให้การจัดการทรัพยากรระบบปฏิบัติการรวมถึงการปิดแอพอยู่ในมือของระบบปฏิบัติการ

โดยส่วนตัวแล้วฉันจะไม่ใช้วิธีการนี้เนื่องจากผู้ใช้ Android คาดหวังว่าแอพจะรักษาความต่อเนื่องเมื่อพวกเขากลับมาเยี่ยมชมและดังนั้นพวกเขาจึงไม่คุ้นเคยกับวิธีการ "ออก" แอพ ฉันอยากจะสนับสนุนฟังก์ชั่น "ล้าง" ที่ผู้ใช้สามารถเรียกใช้เพื่อรีเซ็ตแอพเป็นสถานะเริ่มต้นบางอย่างโดยไม่จำเป็นต้อง "ปล่อย" ไว้ในกระบวนการ

ข้อยกเว้นประการหนึ่งคือเมื่อผู้ใช้กดปุ่มย้อนกลับในจำนวนครั้งที่เพียงพอเพื่อให้แอปปิด ในสถานการณ์ดังกล่าวไม่มีความคาดหวังในส่วนของผู้ใช้ที่สถานะนั้นจะถูกบันทึกไว้ (และหากมีสถานะที่ไม่ได้บันทึกในแอปคุณในฐานะนักพัฒนาควรมีรหัสการจัดการปุ่มย้อนกลับที่ตรวจจับข้อมูลที่ไม่ได้บันทึกไว้และ แจ้งให้ผู้ใช้บันทึกเป็น SharedPreferences หรือไฟล์หรือสื่อที่ไม่ลบเลือนอื่น ๆ )

เกี่ยวกับ system.exit (0):

หากคุณตัดสินใจที่จะใช้ system.exit (0) เพื่อปิดแอปของคุณด้วยความหยาบคายขั้นสุดท้าย (เช่นจากการกดปุ่มย้อนกลับสุดท้าย) ฉันจะเตือนคุณว่าแม้จะใช้งานได้ "" และในบางครั้ง เคสเป็นวิธีเดียวที่ฉันสามารถปิดแอพได้โดยไม่มีร่องรอยเหลืออยู่มีข้อผิดพลาดเล็กน้อยที่เกิดขึ้นใน Jelly Bean เมื่อคุณใช้วิธีนี้

หากคุณใช้รายการแอพล่าสุดเพื่อเปิดแอพของคุณจากนั้นใช้ปุ่มย้อนกลับเพื่อปิดแอพ (โดยที่แอปนั้นถูกใช้งานผ่านระบบออกจาก (0)) รายการแอปล่าสุดจะปรากฏให้เห็นอีกครั้ง ไม่เคยถูกปิด หากคุณแตะที่รายการแอพของคุณในรายการนั้นเพื่อรันเป็นครั้งที่สองจากรายการแอปล่าสุดที่เปิดอยู่แล้วเหมือนเดิมจะไม่มีการตอบกลับ

ฉันสงสัยว่าสาเหตุของปัญหานี้คือรายการแอปล่าสุดอ้างอิงถึงแอปของคุณที่ไม่สามารถใช้งานได้เนื่องจากคุณปิดแอปโดยใช้ system.exit (0) การปิดแอปของคุณอย่างมีอารยธรรมมากขึ้นโดยใช้ finish () อาจแจ้งให้ OS ทราบในลักษณะที่อนุญาตให้รีเฟรชรายการแอพล่าสุด แต่ system.exit (0) ไม่ได้ทำเช่นนี้

นี่ไม่ใช่ปัญหาใหญ่ในตัวของมันเองเพราะมีคนน้อยมากที่จะเปิดแอพจากแอพล่าสุดแล้วออกจากแอพแล้วเปิดทันทีอีกครั้งจากรายการแอพล่าสุดที่เปิดอยู่ และถ้าพวกเขาแตะปุ่มหน้าแรกจากนั้นเปิดรายการแอพล่าสุดอีกครั้งรายการแอพของคุณจะอยู่ที่นั่นและมันจะทำงานได้อย่างสมบูรณ์ แต่ฉันคิดว่ามันแสดงให้เห็นว่าการใช้งานระบบออก (0) สามารถรบกวนการสื่อสารที่เหมาะสมระหว่างแอพของคุณกับระบบปฏิบัติการและสิ่งนี้ชี้ให้เห็นว่าอาจมีผลอื่น ๆ ที่รุนแรงกว่า

ฉันหวังว่าทุกสิ่งจะเปลี่ยนแปลงไปตามกาลเวลา ผู้ใช้ควรจะสามารถฆ่าแอพหรือกระบวนการหากกระบวนการแอปถูกแซนด์บ็อกซ์อย่างถูกต้องโดยระบบปฏิบัติการ มีความคิดว่าควรเขียนแอพอย่างสมบูรณ์หรือผู้ใช้จะใช้เฉพาะแอพที่ทำตามคำแนะนำ SDK ทั้งหมด ฉันคิดว่านั่นเป็นคำสั่งที่สูง

มีการออกแบบเรียบง่าย (ค่อนข้าง) ซึ่งจะช่วยให้คุณได้รับรอบ "ปริศนา" ทางออก ทำให้แอปของคุณมีสถานะ "ฐาน" (กิจกรรม) ซึ่งเป็นเพียงหน้าจอว่าง ในวันแรกของการสร้างกิจกรรมคุณสามารถเปิดกิจกรรมอื่นที่มีฟังก์ชั่นหลักของแอปของคุณอยู่ได้ "exit" สามารถทำได้โดยเสร็จสิ้น () ในกิจกรรมที่สองนี้และกลับไปที่ฐานของหน้าจอว่างเปล่า ระบบปฏิบัติการสามารถเก็บหน้าจอว่างนี้ไว้ในหน่วยความจำได้นานเท่าที่ต้องการ ...

ในสาระสำคัญเนื่องจากคุณไม่สามารถออกจากระบบปฏิบัติการคุณเพียงแปลงร่างเป็นความว่างเปล่าที่สร้างขึ้นเอง

หากไม่มีฟังก์ชั่น exit สำหรับผู้พัฒนาแอพพลิเคชั่นที่จะฆ่าแอพพลิเคชั่นของตัวเองมันเป็นการออกแบบที่แย่มาก

แอปพลิเคชันของฉันต้องอนุญาตให้ผู้ใช้เปลี่ยนข้อมูลแบบไดนามิกในระหว่างรันไทม์และผู้ใช้จำเป็นต้องรีสตาร์ทแอปพลิเคชันของฉันเพื่อให้ผลการเปลี่ยนแปลง แต่ Android ไม่อนุญาตให้แอปพลิเคชันของฉันรีสตาร์ทด้วยตนเอง Android OS มีวงจรชีวิตของแอปพลิเคชันการออกแบบที่แย่มาก

สำหรับการปิดแอพเมื่อใดก็ตามให้ใช้การFLAG_ACTIVITY_CLEAR_TOPตั้งค่าสถานะในเจตนาแล้วsystem.exit();

หรือมีวิธีคล้ายกัน แต่ไม่มีsystem.exit()เมื่อคุณต้องการออกจากการโทรวิธีนี้:

public void exit() {
    startActivity(new Intent(this, HomeActivity.class).
    setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | IntentCompat.FLAG_ACTIVITY_CLEAR_TASK).putExtra(EXIT_FLAG, true));
}

ในHomeActivity.onCreate()รหัสต่อไปนี้ของคุณเพิ่ม

protected void onCreate(Bundle savedInstanceState) {
    if (getIntent().getBooleanExtra(EXIT_FLAG, false)) {
        if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) == 0) {
            finish();
        }
    }
......................

สิ่งนี้จะทำงานโดยไม่ทำลายวงจรชีวิตของ Android

ประการแรกไม่เคยไม่เคยใช้ System.exit (0) มันเหมือนกับการทำให้คนหลับต่อยเขาบนหัว!

ประการที่สอง: ฉันประสบปัญหานี้ ก่อนที่จะแบ่งปันโซลูชันของฉันฉันต้องการแบ่งปันความคิดของฉัน

ฉันคิดว่า "ปุ่มออก" นั้นโง่ โง่จริงๆจริงๆ และฉันคิดว่าผู้ใช้ (ผู้บริโภค) ที่ขอปุ่มออกสำหรับแอปพลิเคชันของคุณก็โง่เช่นกัน พวกเขาไม่เข้าใจว่าระบบปฏิบัติการทำงานอย่างไรและมีการจัดการทรัพยากรอย่างไร (และทำงานได้ยอดเยี่ยม)

ฉันคิดว่าถ้าคุณเขียนโค้ดที่ดีซึ่งทำสิ่งที่ถูกต้อง (อัปเดตบันทึกและดัน) ในเวลาและเงื่อนไขที่ถูกต้องและใช้สิ่งที่ถูกต้อง (บริการและตัวรับ) มันจะทำงานได้ดีและไม่มีใครบ่น .

แต่คุณต้องศึกษาและเรียนรู้วิธีการทำงานของ Android อย่างไรก็ตามนี่เป็นวิธีแก้ปัญหาของฉันที่จะมอบ "ปุ่มออก" ให้กับผู้ใช้

ฉันสร้างเมนูตัวเลือกที่สามารถมองเห็นได้ในแต่ละกิจกรรม (ฉันเป็นกิจกรรมที่ยอดเยี่ยม)

เมื่อผู้ใช้คลิกที่ปุ่มนี่คือสิ่งที่เกิดขึ้น:

Intent intent = new Intent(this, DashBoardActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

SharedPreferences settings = getSharedPreferences(getString(PREF_ID), Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(FORCE_EXIT_APPLICATION, true);

  // Commit the edits!
editor.commit();
startActivity(intent);
finish();

ดังนั้นฉันบันทึกใน SharedPreferences ที่ฉันต้องการจะฆ่าแอพของฉันและฉันเริ่มเจตนา โปรดดูที่ธงเหล่านั้น สิ่งเหล่านั้นจะล้าง backstack ทั้งหมดของฉันที่เรียกกิจกรรม DashBoard ของฉันซึ่งเป็นกิจกรรม "บ้าน" ของฉัน

ดังนั้นในกิจกรรมแดชบอร์ดของฉันฉันใช้วิธีนี้ใน onResume:

private void checkIfForceKill() {

    // CHECK IF I NEED TO KILL THE APP

    // Restore preferences
    SharedPreferences settings = getSharedPreferences(
            getString(MXMSettingHolder.PREF_ID), Context.MODE_PRIVATE);
    boolean forceKill = settings.getBoolean(
            MusicSinglePaneActivity.FORCE_EXIT_APPLICATION, false);

    if (forceKill) {

        //CLEAR THE FORCE_EXIT SETTINGS
        SharedPreferences.Editor editor = settings.edit();
        editor.putBoolean(FORCE_EXIT_APPLICATION, false);

        // Commit the edits!
        editor.commit();

        //HERE STOP ALL YOUR SERVICES
        finish();
    }
}

และมันจะทำงานได้ค่อนข้างดี

สิ่งเดียวที่ฉันไม่เข้าใจว่าทำไมมันเกิดขึ้นคือเมื่อฉันทำเสร็จสุดท้าย (และฉันได้ตรวจสอบ: มันติดตามกระแสที่ถูกต้องทั้งหมดของ onPause → onStop → onDestroy) แอปพลิเคชันยังคงอยู่ในกิจกรรมล่าสุด (แต่ มันว่างเปล่า)

ดูเหมือนว่าเจตนาล่าสุด (ที่เริ่มต้น DashboardActivity) ยังคงอยู่ในระบบ

ฉันขุดมากขึ้นเพื่อที่จะลบมันออกไป

วงจรชีวิตแอปพลิเคชัน Android ออกแบบมาสำหรับผู้ใช้โทรศัพท์มือถือไม่ใช่ผู้ใช้คอมพิวเตอร์

วงจรชีวิตของแอพเป็นกระบวนทัศน์ที่เรียบง่ายอย่างไร้ความปราณีที่ต้องการเปลี่ยนเซิร์ฟเวอร์ Linux ให้กลายเป็นอุปกรณ์สำหรับผู้บริโภค

Android เป็น Java ผ่าน Linux ซึ่งเป็นระบบปฏิบัติการเซิร์ฟเวอร์ข้ามแพลตฟอร์มที่แท้จริง นั่นคือวิธีที่มันแพร่กระจายอย่างรวดเร็ว วงจรชีวิตของแอปนั้นสรุปความเป็นจริงพื้นฐานของระบบปฏิบัติการ

สำหรับผู้ใช้มือถือแอพเพิ่งติดตั้งหรือไม่ได้ติดตั้ง ไม่มีแนวคิดของการรันหรือออก ในความเป็นจริงกระบวนการแอปมีขึ้นเพื่อให้ทำงานจนกว่าระบบปฏิบัติการจะเผยแพร่พวกเขาสำหรับทรัพยากรที่มีอยู่

เนื่องจากนี่คือ Stack Overflow ทุกคนที่อ่านข้อความนี้เป็นผู้ใช้คอมพิวเตอร์และต้องปิดความรู้ 90% เพื่อทำความเข้าใจวงจรชีวิตของแอปมือถือ

ฉันใช้เวลาอ่านคำถามและคำตอบนี้นานกว่าการใช้งานแอปพลิเคชัน Android แบบกึ่งกึ่งกลาง

มันเป็นแอพ GPS ที่โพลคะแนนและส่งตำแหน่งปัจจุบันไปยัง webservice ทุก ๆ สองสามวินาทีโดยใช้เธรด ... ซึ่งสามารถสำรวจทุก 5 นาทีในกรณีของ Ted เพื่ออัปเดตจากนั้น onStop ก็สามารถเริ่มกิจกรรมอัปเดต Ted ได้เลย ความกังวลเกี่ยวกับหากพบว่า (asynchronous Ted, ไม่รหัสเช่นโปรแกรมเมอร์ Windows หรือโปรแกรมของคุณจะทำงานเหมือนโปรแกรม Windows ... eww มันไม่ยากเลย)

ฉันได้รหัสเริ่มต้นใน onCreate เพื่อตั้งค่าสิ่งต่าง ๆ สำหรับอายุการใช้งานของกิจกรรมรวมถึงcheckUpdate.start();:

...

@Override
public void onStart() {
    super.onStart();
    isRemote = true;
    checkUpdate.resume();

    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 0, luh);
}

@Override
public void onPause() {
    isRemote = false;
    checkUpdate.suspend();
    locationManager.removeUpdates(luh);
    super.onStop();
}

รหัสนี้อาจผิดทั้งหมด แต่ใช้งานได้ นี่เป็นหนึ่งในแอปพลิเคชัน Android เครื่องแรกของฉัน

แอปพลิเคชันที่ไม่กิน CPU เมื่ออยู่ในพื้นหลัง แต่พร้อมที่จะเปิดใหม่ทันทีเนื่องจากอยู่ใน RAM (แม้ว่าจะไม่ถือ RAM เหมือนวงจรชีวิตของ Android) ... แอปพร้อมเสมอโทรศัพท์ , ผู้ชาย / gals หากแอปใช้ RAM ทั้งหมดและไม่สามารถปิดได้โดยระบบปฏิบัติการสิ่งนั้นอาจหยุดดัง = P นั่นเป็นสาเหตุที่ระบบปฏิบัติการต้องปิดแอปของคุณเมื่ออยู่ในพื้นหลัง (หากแอปพลิเคชันของคุณไม่อยู่ ทรัพยากรมันจะไม่ถูกปิด BTW) ดังนั้นลองเขียนแอปพลิเคชันที่ดีกว่า

ทุกครั้งที่คุณย้ายไปยังหน้าถัดไปด้วยเจตนาใช้:

`YourActivityname.this.finish()`;

ตัวอย่าง:

Intent intent = new Intent(getApplicationContext(), SMS.class);

startActivity(intent);
MainActivity.this.finish();

เพื่อไม่ให้กิจกรรมใดทำงานบนพื้นหลังและเมื่อคุณต้องการออกจากแอปให้ใช้:

MainActivity.this.finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
getParent().finish();

การออกจากนี้ได้ผลเหมือนเป็นเสน่ห์สำหรับฉัน :)

ในกรณีใด ๆ System.exit(0);ถ้าคุณต้องการที่จะยุติการใช้งานของคุณคุณสามารถเรียก

หากคุณมี 10,20 .. กิจกรรมหลายอย่างกำลังทำงานอยู่และคุณต้องการที่จะทำกิจกรรมทั้งหมดให้เสร็จสิ้นและออกจากระบบ

สร้างอาร์เรย์แบบคงที่ในapplication classหรือconstants class.

ค่าคงที่

public class Constants {

public static ArrayList<Activity> activities = new ArrayList<Activity>();

}

MainActivity เพิ่มการอ้างอิงกิจกรรมปัจจุบันในอาร์เรย์นี้

activity = MainActivity.this; Constants.activities.add(activity);

public class MainActivity extends Activity {

    private ImageView imageButton;
    private Activity activity;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        activity = MainActivity.this;
        Constants.activities.add(activity);

        imageButton = (ImageView) findViewById(R.id.camera);
        imageButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                // existing app.
                if (Constants.activities != null) {
                    for (int i = 0; i < Constants.activities.size(); i++) {
                        Activity s = Constants.activities.get(i);
                        s.finish();
                    }
                }
                //super.finish();
                finish();
                android.os.Process.killProcess(android.os.Process.myPid());
                System.exit(1);
            }
        });
    }
}