Android uygulamasından programlı olarak çıkma

Programlı bir Android uygulamasından çıkmak için bazı kodlar buldum. OnDestroy () içinde aşağıdaki kodlardan herhangi birini çağırarak uygulamadan tamamen çıkacak mı?

1. System.runFinalizersOnExit(true)
   (VEYA)
2. android.os.Process.killProcess(android.os.Process.myPid());

Çık düğmesine tıkladıktan sonra uygulamamı arka planda çalıştırmak istemiyorum. Pls bana benim app çıkmak için bu kod herhangi birini kullanabilirsiniz öneririz? Varsa hangi kodu kullanabilirim? Android'de uygulamadan çıkmanın iyi bir yolu var mı?

API 16'dan beri, ilgili tüm etkinlikleri adıyla ve Javadoc açıklamasına göre kapatmaya oldukça yakın görünen finishAffinity yöntemini kullanabilirsiniz:

this.finishAffinity();

Bu etkinliği ve aynı afiniteye sahip geçerli görevde hemen altındaki tüm etkinlikleri bitirin. Bu genellikle bir uygulama başka bir göreve (anladığı bir içerik türünün ACTION_VIEW öğesinden) başlatılabildiğinde ve kullanıcı geçerli görevden çıkmak ve kendi görevine geçmek için yukarı gezinmeyi kullandığında kullanılır. Bu durumda, kullanıcı ikinci uygulamanın diğer etkinliklerine inerse, bunların tümü görev anahtarının bir parçası olarak orijinal görevden kaldırılmalıdır.

Bu sonlandırmanın sonuçları önceki etkinliğe iletmenize izin vermediğini ve bunu yapmaya çalışıyorsanız bir istisna atılacağını unutmayın.

API 21'den beri çok benzer bir komut kullanabilirsiniz

finishAndRemoveTask();

Bu görevdeki tüm etkinlikleri sonlandırır ve son görevler listesinden kaldırır.

getActivity().finish();
System.exit(0);

Bu app çıkmak için en iyi yoldur. !!!

Benim için en iyi çözüm.

finishAffinity();

System.exit(0);

Sadece uygulamanız finishAffinity();olmadan kullanacaksanız System.exit(0);ayrılacak, ancak ayrılan bellek yine de telefonunuz tarafından kullanılacaktır, bu yüzden ... bir uygulamanın temiz ve gerçekten çıkmasını istiyorsanız, her ikisini de kullanın.

Bu en basit yöntemdir ve her yerde çalışır, gerçek uygulamadan çıkın, açılmış bir çok aktivite hala sorun olmadan tüm bırakacak.

bir düğme tıklamasıyla örnek

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

veya hoş bir şey istiyorsanız, örneğin 3 düğmeli bir uyarı iletişim kutusu ile EVET HAYIR ve İPTAL

// alertdialog for exit the app
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

// set the title of the Alert Dialog
alertDialogBuilder.setTitle("your title");

// set dialog message
alertDialogBuilder
        .setMessage("your message")
        .setCancelable(false)
        .setPositiveButton("YES"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // what to do if YES is tapped
                        finishAffinity();
                        System.exit(0);
                    }
                })

        .setNeutralButton("CANCEL"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on CANCEL tapped
                        dialog.cancel();
                    }
                })

        .setNegativeButton("NO"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on NO tapped
                        dialog.cancel();
                    }
                });

AlertDialog alertDialog = alertDialogBuilder.create();

alertDialog.show();

Uygulamayı öldürmeniz gerekiyorsa lütfen gerçekten çok düşünün: neden işletim sisteminin kaynakları nerede ve ne zaman serbest bırakacağını anlamasına izin vermiyorsunuz?

Aksi takdirde, kesinlikle gerçekten eminseniz,

finish();

@Dave appleton yorumuna bir tepki olarak: İlk şey büyük soru / cevap okumak combo @gabriel gönderdi: Bir uygulama bırakma kaşlarını çattı mı?

Şimdi buna sahip olduğumuzu varsayarsak, buradaki sorunun hala bir cevabı var, bırakma ile herhangi bir şey yapıyorsanız ihtiyacınız olan kod olması finish(). Açıkçası birden fazla aktivite vb. Olabilir, ama mesele bu değil. Bazı kullanım senaryoları tarafından çalışalım

1. Kullanıcının bellek kullanımı ve "arka planda çalışmıyor" şüphesi nedeniyle her şeyi bırakmak istiyorum. Kullanıcının arka planda belirli faaliyetleri durdurmasına izin verin, ancak işletim sisteminin gereksiz başvuruları öldürmesine izin verin.
2. Bir kullanıcının uygulamanızın önceki etkinliğine gitmesini istemiyor musunuz? Peki, ya yapılandırmayın, ya da ekstra bir seçeneğe ihtiyacınız var. Çoğu zaman geri = önceki etkinlik işe yararsa, kullanıcı başka bir şey yapmak isterse eve basmaz mı?
3. Bir çeşit sıfırlamaya ihtiyacınız varsa, uygulamanızın / nasıl / vb. Bırakıldığını öğrenebilirsiniz ve etkinliğiniz tekrar odaklanırsa, nerede olduğunuzu yeniden başlatmak yerine yeni bir ekran göstererek bununla ilgili işlem yapabilirsiniz.

Sonuçta, elbette, finish()her şeyi öldürmez, ama bence hala ihtiyacınız olan araç. "Tüm aktiviteleri öldür" için bir kullanıcı tabanı varsa, henüz bulamadım.

Bazı durumlarda uygulamanın öldürülmesi gerektiğini düşünüyorum. Örneğin, bir uygulama sadece giriş yaptıktan sonra kullanılabilir. Giriş etkinliğinin iki düğmesi vardır, 'giriş' ve 'iptal'. 'İptal' düğmesini tıkladığınızda, kesinlikle 'Uygulamayı sonlandır' anlamına gelir. Kimse uygulamanın arka planda canlı olmasını istemiyor. Bu yüzden bazı durumlarda uygulamayı kapatmanız gerektiğini kabul ediyorum.

Bir oluşturun ExitActivityve bildirimde beyan edin. Ve ExitActivity.exit(context)uygulamadan çıkmak için arayın.

public class ExitActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        finish();
    }

    public static void exit(Context context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        context.startActivity(intent);
    }

}

Android'de bir uygulama yok , SampleActivity.this.finish (); geçerli etkinliği tamamlayacaktır.

Bir aktiviteden diğerine geçtiğinizde öncekini bitirmeye devam edin

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();

Her şeyden önce, bu yaklaşım min Api 16 gerektirir.

Bu sorunu daha geniş bir şekilde çözmek için bu çözümü 3 bölüme ayıracağım.

1. Bir Etkinlikteki uygulamadan çıkmak istiyorsanız bu kod snippet'ini kullanın:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    finishAndRemoveTask();
}

2. Uygulamaya, Etkinlik erişimi olan bir Etkinlik dışı sınıfta çıkmak istiyorsanız, bu kod snippet'ini kullanın:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    getActivity().finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    getActivity().finishAndRemoveTask();
}

3. Uygulamadan bir Activity olmayan sınıfta çıkmak ve Service gibi Activity'ye erişemiyorsanız BroadcastReceiver kullanmanızı öneririm. Bu yaklaşımı projenizdeki tüm Etkinliklerinize ekleyebilirsiniz.

LocalBroadcastManager ve BroadcastReceiver örnek değişkenleri oluşturun. İsterseniz getPackageName () + ". Closeapp" ifadesini değiştirebilirsiniz.

LocalBroadcastManager mLocalBroadcastManager;
BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction().equals(getPackageName()+".closeapp")){
            if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }
        }
    }
};

Bunları onCreate () yöntemine ekleyin.

mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
IntentFilter mIntentFilter = new IntentFilter();
mIntentFilter.addAction(getPackageName()+".closeapp");
mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

Ayrıca, onDestroy () yönteminde unregister alıcısını çağırmayı unutmayın

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Uygulamadan çıkmak için, hizmeti genişleten PlayService sınıfımda kullandığım LocalBroadcastManager'ı kullanarak yayın göndermeniz gerekir.

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(PlayService.this);
localBroadcastManager.sendBroadcast(new Intent(getPackageName() + ".closeapp"));

finishAndRemoveTask ()API 21'den kullanabilirsiniz

public void finishAndRemoveTask ()

Bu görevdeki tüm etkinlikleri sonlandırır ve son görevler listesinden kaldırır.

Uygulamanızı ne kadar hızlı kapatmak istediğinize bağlıdır.

Uygulamanızı kapatmanın güvenli bir yolu finishAffinity ();

Tüm işlemler işlendikten sonra uygulamayı kapatır. Bu biraz zaman alabilir. Uygulamanızı bu şekilde kapatır ve kısa bir süre sonra yeniden başlatırsanız, yeni uygulamanız aynı işlemde çalışıyor olabilir. Eski uygulamanın tüm bitmemiş süreçleri ve singleton nesneleri ile.

Uygulamanızın tamamen kapalı olduğundan emin olmak istiyorsanız System.exit (0) öğesini kullanın ;

Bu, uygulamanızı hemen kapatır. Ancak, uygulamanızın açık olduğu dosyalara zarar vermeniz veya paylaşılan tercihlerde bir düzenlemenin bitmemesi mümkündür. Bu yüzden dikkatli kullanın.

Watchdog'u uzun süren bir görevle birlikte kullanıyorsanız, farklı yöntemlerin etkilerini görebilirsiniz.

new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
    public void onAppNotResponding(ANRError error) {
        MainActivity.this.finishAffinity();
        System.exit(0);
    }
}).start();
for(int i = 0; i < 10; ++i){
    --i;
}

Bu, bir ANR iletişim kutusu veya benzeri bir şey görüntülemeden uygulamanızı 2 saniye sonra öldürür. System.exit (0) öğesini kaldırırsanız , bu kodu çalıştırın ve kapatıldıktan sonra uygulamayı yeniden başlatın, sonsuz döngü hala çalıştığı için bazı garip davranışlarla karşılaşacaksınız.

Daha iyi kullanım vardı finish()sen ise Activityya getActivity().finish()sen ise Fragment.

Uygulamadan tamamen çıkmak istiyorsanız, şunu kullanın:

getActivity().finish();
System.exit(0);

Uygulamadan çıkmanın kolay ve basit yolu

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);

Sağlam ve basit kod istiyoruz. Bu çözüm eski cihazlarda ve daha yeni cihazlarda çalışır.

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }

Bence aradığın şey bu

activity.moveTaskToBack(Boolean nonRoot);

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }

@MobileMateo benzer, ancak Kotlin

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}

Bunun kaşlarını çatıp çatlamadığından emin değilim, ama ben böyle yaparım ...

Adım 1 - Genel olarak erişmek istediğim yöntemleri ve değişkenleri içeren bir sınıfım var. Bu örnekte "App" sınıfı diyeceğim. Uygulamanızın sahip olduğu her etkinlik için sınıf içinde statik bir Etkinlik değişkeni oluşturun. Daha sonra finish(), bu etkinlik değişkenlerinin her birinde null DEĞİLSE yöntemi çalıştıracak "close" adlı statik bir yöntem oluşturun . Bir ana / ebeveyn etkinliğiniz varsa, son olarak kapatın:

public class App
{
    ////////////////////////////////////////////////////////////////
    // INSTANTIATED ACTIVITY VARIABLES
    ////////////////////////////////////////////////////////////////

        public static Activity activity1;
        public static Activity activity2;
        public static Activity activity3;

    ////////////////////////////////////////////////////////////////
    // CLOSE APP METHOD
    ////////////////////////////////////////////////////////////////

        public static void close()
        {
            if (App.activity3 != null) {App.activity3.finish();}
            if (App.activity2 != null) {App.activity2.finish();}
            if (App.activity1 != null) {App.activity1.finish();}
        }
}

2. Adım - Etkinliklerinizin her birinde onStart()ve onDestroy()yöntemlerini geçersiz kılın . Alanında onStart(), App sınıfınızdaki statik değişkeni " this" değerine ayarlayın . In onDestroy()değerine eşit olarak ayarlayın null. Örneğin, "Activity1" sınıfında:

@Override
public void onStart()
{
    // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

        super.onStart();
        App.activity1 = this;
}

@Override
public void onDestroy()
{
    // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

        super.onDestroy();
        App.activity1 = null;
}

Adım 3 - Uygulamanızı kapatmak istediğinizde istediğiniz App.close()yerden arayın . Tüm somut faaliyetler kapanacak! Yalnızca etkinlikleri kapattığınız ve uygulamanın kendisini öldürmediğiniz için (örneklerinizdeki gibi), Android oradan devralmak ve gerekli temizlik işlemlerini yapmakta serbesttir.

Yine, bunun herhangi bir nedenle kaşlarını çatıp çırpmayacağını bilmiyorum. Eğer öyleyse, neden ve nasıl geliştirilebileceğine dair yorumları okumak isterim!

Başvurudan vazgeçmek kaşlarını çattı mı? . Bu bağlantıdan geçin. Sorunuzu cevaplıyor. Sistem bir uygulamayı öldürme işini yapar.

A ve B olmak üzere iki etkinliğiniz olduğunu varsayalım. A'dan B'ye gidersiniz. Geri düğmesine tıkladığınızda, B etkinliğiniz backstack'tan çıkarılır ve yok edilir. Arka yığın A aktivitesinde önceki aktivite odaklanır.

Uygulamayı ne zaman öldüreceğinize karar vermek için sisteme bırakmalısınız.

Kamu geçersiz finish()

Etkinliğiniz tamamlandığında ve kapatılması gerektiğinde bunu arayın.

Birçok etkinliğiniz olduğunu varsayalım. Eylem çubuğunu kullanabilirsiniz. Ana sayfa simgesine tıkladığınızda uygulamanızın MainActivity'ye yönlendirin. MainActivity'de uygulamadan çıkmak için geri düğmesine tıklayın.

Uygulamadan çıkmak için aşağıdakileri kullanabilirsiniz:

getActivity().finish();
Process.killProcess(Process.myPid());
System.exit(1);

Ayrıca hizmetleri durdurmak için aşağıdaki yöntemi de arayın:

private void stopServices() {        
    final ActivityManager activityManager = SystemServices.getActivityManager(context);
    final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
    final int pid = Process.myPid();
    for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
        if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
            try {
                final Intent intent = new Intent();
                intent.setComponent(serviceInfo.service);
                context.stopService(intent);
            } catch (SecurityException e) { 
                 // handle exception
            }
        }
    }
}

Bu çok geç olabilir ve aynı zamanda yaşam döngüsü sürecini kendiniz halletmemeniz gereken yönergelere göre (işletim sistemi sizin için yapar gibi). Bir öneri, tüm etkinliklerinize " finish()" ile bir yayın alıcısı kaydetmeniz onReceive() ve her ne zaman çıkmak istediğinizde tüm etkinliklerin kapatılması gerektiğini belirten bir niyet iletebilirsiniz ... alıcıdaki onDestroy()yöntemlerin kaydını kaldırın .

Bu iyi bir karar değil, çünkü Android'in uygulama işleme ilkelerine aykırı. Kesinlikle kaçınılmaz olan Android hiçbir işlemi öldürmez. Bu, uygulamaların daha hızlı başlamasına yardımcı olur, çünkü her zaman bellekte tutulurlar. Bu nedenle, uygulamanızın sürecini öldürmek için çok özel bir nedene ihtiyacınız var.

Düğme tıklamasıyla uygulamadan çıkmak için doğru ve kesin çözüm aşağıdaki kodu kullanmaktır:

// Açık Düğmesi Geri basılan olay

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}

Kotlin kullanıyorsanız, uygulamadan çıkmanın ve alternatifin System.exit()yerleşik bir yöntem olduğu

exitProcess(0)

Belgelere bakın .

Parametre 0olarak sayı , çıkışın amaçlandığı ve herhangi bir hata oluşmadığı anlamına gelir.

Bu her şeyi öldürür;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);

Bunu dene

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);

Android'in mantığını bozmadan ve mevcut etkinliklere daha fazla kod eklemeden ve ekstraları geçmeden bir uygulamadan bir etkinlikten çıkmanın en kolay yolu şudur:

public static void quitApplication (Activity currentActivity) {
    Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

    currentActivity.startActivity (intent);
    currentActivity.finish ();
}

QuitApplicationActivityvarlık:

public class QuitApplicationActivity extends AppCompatActivity {

    @Override
    protected void onCreate (Bundle savedInstanceState) {
        super.onCreate (savedInstanceState);

        finish ();
    }
}

@Sivi'nin cevabı uygulamayı kapatır. Ancak karşılığında, bazı çocuk aktiviteleriniz varsa, başka bir tamamlanmamış aktivite açılabilir. Eklediğim noHistory:truedönüş uygulaması MainActivity başlar yani benim faaliyetlerine.

<activity 
      android:name=".MainActivity"
      android:noHistory="true">
</activity>

Sadece bir uygulamayı sonlandırmak için acımasız yöntemler listesine bir tane eklemek için:

Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

tüm uygulamalarınızdan çıkabilirsiniz. Böylece

Intent intent = getBaseContext().getPackageManager()
             .getLaunchIntentForPackage(getBaseContext().getPackageName());
intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

% 100 çalışacaktır. İyi şanslar!

Sadece tuş üzerinde bitirmek () kullanın onKeypressed ()