Program ProgressDialog jest przestarzały. Jakiego alternatywnego użyć?

Przekonałem się, że ProgressDialogjest to już nieaktualne. Co byłoby alternatywne zamiast tego ProgressBar. Używam Androida Studio w wersji 2.3.3.

ProgressDialog progressDialog=new ProgressDialog(this);
progressDialog.show();

Tak, API level 26jest przestarzałe. Zamiast tego możesz użyć progressBar.

Aby utworzyć programowo:

Najpierw zapoznaj się z układem głównym

RelativeLayout layout = findViewById(R.id.display);  //specify here Root layout Id

lub

RelativeLayout layout = findViewById(this);

Następnie dodaj pasek postępu

progressBar = new ProgressBar(youractivity.this, null, android.R.attr.progressBarStyleLarge);
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(100, 100);
params.addRule(RelativeLayout.CENTER_IN_PARENT);
layout.addView(progressBar, params);

Aby wyświetlić pasek postępu

progressBar.setVisibility(View.VISIBLE);

Aby ukryć pasek postępu

progressBar.setVisibility(View.GONE);

Aby wyłączyć interakcję użytkownika, wystarczy dodać następujący kod

getWindow().setFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
                           WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

Aby odzyskać interakcję użytkownika, wystarczy dodać następujący kod

getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

Tylko dla odniesienia w przyszłości, należy zmienić android.R.attr.progressBarStyleSmallsię android.R.attr.progressBarStyleHorizontal.

Poniższy kod działa tylko powyżej API level 21

progressBar.setProgressTintList(ColorStateList.valueOf(Color.RED));

Aby go utworzyć za pomocą xml:

<ProgressBar
        android:id="@+id/progressbar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:indeterminate="true"
        android:max="100"
        android:backgroundTint="@color/white"
        android:layout_below="@+id/framelauout"
        android:indeterminateTint="#1a09d6"
        android:layout_marginTop="-7dp"/>

W twojej działalności

progressBar = (ProgressBar) findViewById(R.id.progressbar);

Wyświetlanie / ukrywanie paska postępu jest takie samo

 progressBar.setVisibility(View.VISIBLE); // To show the ProgressBar 
 progressBar.setVisibility(View.INVISIBLE); // To hide the ProgressBar

Oto przykładowy obraz tego, jak by to wyglądało:

Aby uzyskać więcej informacji:
1. Referencja pierwsza
2. Referencja druga

możesz użyć AlertDialogjako ProgressDialogpatrz poniżej kod dla ProgressDialog. Tę funkcję musisz wywołać za każdym razem, gdy wyświetli się okno dialogowe postępu.

Kod:

    public void setProgressDialog() {

    int llPadding = 30;
    LinearLayout ll = new LinearLayout(this);
    ll.setOrientation(LinearLayout.HORIZONTAL);
    ll.setPadding(llPadding, llPadding, llPadding, llPadding);
    ll.setGravity(Gravity.CENTER);
    LinearLayout.LayoutParams llParam = new LinearLayout.LayoutParams(
            LinearLayout.LayoutParams.WRAP_CONTENT,
            LinearLayout.LayoutParams.WRAP_CONTENT);
    llParam.gravity = Gravity.CENTER;
    ll.setLayoutParams(llParam);

    ProgressBar progressBar = new ProgressBar(this);
    progressBar.setIndeterminate(true);
    progressBar.setPadding(0, 0, llPadding, 0);
    progressBar.setLayoutParams(llParam);

    llParam = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
            ViewGroup.LayoutParams.WRAP_CONTENT);
    llParam.gravity = Gravity.CENTER;
    TextView tvText = new TextView(this);
    tvText.setText("Loading ...");
    tvText.setTextColor(Color.parseColor("#000000"));
    tvText.setTextSize(20);
    tvText.setLayoutParams(llParam);

    ll.addView(progressBar);
    ll.addView(tvText);

    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setCancelable(true);
    builder.setView(ll);

    AlertDialog dialog = builder.create();
    dialog.show();
    Window window = dialog.getWindow();
    if (window != null) {
        WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
        layoutParams.copyFrom(dialog.getWindow().getAttributes());
        layoutParams.width = LinearLayout.LayoutParams.WRAP_CONTENT;
        layoutParams.height = LinearLayout.LayoutParams.WRAP_CONTENT;
        dialog.getWindow().setAttributes(layoutParams);
    }
}

Wynik:

Ta klasa została wycofana z poziomu 26 interfejsu API. ProgressDialog to modalne okno dialogowe, które uniemożliwia użytkownikowi interakcję z aplikacją. Zamiast korzystać z tej klasy, należy użyć wskaźnika postępu, takiego jak ProgressBar, który można osadzić w interfejsie aplikacji. Alternatywnie możesz użyć powiadomienia, aby poinformować użytkownika o postępie zadania. połączyć

Jest przestarzałe ze Android Owzględu na Googlenowy standard interfejsu użytkownika

Możesz po prostu zaprojektować interfejs XML dla paska postępu i przekazać go jako widok do AlertDialog, a następnie wyświetlić lub zamknąć okno dialogowe w dowolnym momencie.

progress.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:padding="13dp"
    android:layout_centerHorizontal="true"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">

    <ProgressBar
        android:id="@+id/loader"
        android:layout_marginEnd="5dp"
        android:layout_width="45dp"
        android:layout_height="45dp" />
    <TextView
        android:layout_width="wrap_content"
        android:text="Loading..."
        android:textAppearance="?android:textAppearanceSmall"
        android:layout_gravity="center_vertical"
        android:id="@+id/loading_msg"
        android:layout_toEndOf="@+id/loader"
        android:layout_height="wrap_content" />

</LinearLayout>

Kod kodu wyświetlający okno dialogowe postępu. Po prostu skopiuj ten kod i wklej go we fragmencie.

  AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
       private void setDialog(boolean show){
            builder.setView(R.layout.progress);
            Dialog dialog = builder.create();
            if (show)dialog.show();
            else dialog.dismiss();
        }

Następnie po prostu wywołaj metodę za każdym razem, gdy chcesz pokazać progressdialog i przekazać true jako argument, aby go pokazać, lub false, aby zamknąć okno dialogowe.

Pasek postępu jest bardzo prosty i łatwy w użyciu, zamierzam zrobić to samo, co proste okno dialogowe postępu. Pierwszym krokiem jest to, że możesz utworzyć układ xml okna dialogowego, które chcesz pokazać, powiedzmy, że nazywamy ten układ

layout_loading_dialog.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:padding="20dp">
    <ProgressBar
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1" />

    <TextView
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="4"
        android:gravity="center"
        android:text="Please wait! This may take a moment." />
</LinearLayout>

następnym krokiem jest utworzenie AlertDialog, który pokaże ten układ za pomocą ProgressBar

AlertDialog.Builder builder = new AlertDialog.Builder(context);
builder.setCancelable(false); // if you want user to wait for some process to finish,
builder.setView(R.layout.layout_loading_dialog);
AlertDialog dialog = builder.create();

teraz pozostaje tylko pokazać i ukryć to okno dialogowe w naszych zdarzeniach związanych z kliknięciem

dialog.show(); // to show this dialog
dialog.dismiss(); // to hide this dialog

i to wszystko, powinno działać, jak widać, jest to bardzo proste i łatwe do wdrożenia ProgressBar zamiast ProgressDialog. teraz możesz pokazać / odrzucić to okno dialogowe w module obsługi lub ASyncTask, zależnie od potrzeb

Tak, ProgressDialog jest przestarzały, ale Dialog nie.

Możesz nadmuchać własny plik XML (zawierający pasek postępu i ładujący tekst) do obiektu okna dialogowego, a następnie wyświetlić lub ukryć go za pomocą funkcji show()i dismiss(). Oto przykład (Kotlin):

Klasa ProgressDialog :

class ProgressDialog {
companion object {
    fun progressDialog(context: Context): Dialog{
        val dialog = Dialog(context)
        val inflate = LayoutInflater.from(context).inflate(R.layout.progress_dialog, null)
        dialog.setContentView(inflate)
        dialog.setCancelable(false)
        dialog.window!!.setBackgroundDrawable(
                ColorDrawable(Color.TRANSPARENT))
        return dialog
    }
  }
}

XML

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent"
android:background="#fff"
android:padding="13dp"
android:layout_height="wrap_content">
<ProgressBar
    android:id="@+id/progressBar"
    style="?android:attr/progressBarStyle"
    android:layout_width="100dp"
    android:layout_margin="7dp"
    android:layout_height="100dp"
    android:layout_above="@+id/no_jobs_pickups"/>
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerVertical="true"
    android:layout_margin="7dp"
    android:layout_toEndOf="@+id/progressBar"
    android:text="Loading..." />
</RelativeLayout>

W twoim kodzie : po prostu zróbvar dialog = ProgressDialog.progressDialog(context)

Pokazywać: dialog.show()

Ukryć: dialog.dismiss()

Cóż, jeśli naprawdę chcesz postępować wbrew ich woli, nadal możesz użyć Sweet Alert Dialog lub stworzyć go samodzielnie.

progress_dialog_layout

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TableRow
        android:layout_centerInParent="true"
        android:layout_width="match_parent"
        android:layout_height="64dp" >

        <ProgressBar
            android:id="@+id/progressBar2"
            style="?android:attr/progressBarStyle"
            android:layout_width="wrap_content"
            android:layout_height="match_parent" />

        <TextView
            android:gravity="center|left"
            android:id="@+id/textView9"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:textColor="@color/black"
            android:textSize="18sp"
            android:text="Downloading data. Please wait.." />
    </TableRow>
</RelativeLayout>

Kod Java:

AlertDialog b;
AlertDialog.Builder dialogBuilder;

public void ShowProgressDialog() {
dialogBuilder = new AlertDialog.Builder(DataDownloadActivity.this);
LayoutInflater inflater = (LayoutInflater) getSystemService( Context.LAYOUT_INFLATER_SERVICE );
            View dialogView = inflater.inflate(R.layout.progress_dialog_layout, null);
            dialogBuilder.setView(dialogView);
            dialogBuilder.setCancelable(false);
            b = dialogBuilder.create();
            b.show();
        }

        public void HideProgressDialog(){

            b.dismiss();
        }

ProgressBar jest najlepszą alternatywą dla ProgressDialog. Element interfejsu użytkownika wskazujący postęp operacji.

Aby uzyskać więcej informacji, zobacz ten dokument Google: https://developer.android.com/reference/android/widget/ProgressBar.html

Nie musisz importować żadnej niestandardowej biblioteki.

Wolę korzystać z nowoczesnego, AlertDialogwięc jest to wersja Kotlin dla świetnej odpowiedzi opublikowanej przez Kishana Dongę na tej stronie.

Kod Kotlin:

fun setProgressDialog(context:Context, message:String):AlertDialog {
    val llPadding = 30
    val ll = LinearLayout(context)
    ll.orientation = LinearLayout.HORIZONTAL
    ll.setPadding(llPadding, llPadding, llPadding, llPadding)
    ll.gravity = Gravity.CENTER
    var llParam = LinearLayout.LayoutParams(
                  LinearLayout.LayoutParams.WRAP_CONTENT,
                  LinearLayout.LayoutParams.WRAP_CONTENT)
    llParam.gravity = Gravity.CENTER
    ll.layoutParams = llParam

    val progressBar = ProgressBar(context)
    progressBar.isIndeterminate = true
    progressBar.setPadding(0, 0, llPadding, 0)
    progressBar.layoutParams = llParam

    llParam = LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
                        ViewGroup.LayoutParams.WRAP_CONTENT)
    llParam.gravity = Gravity.CENTER
    val tvText = TextView(context)
    tvText.text = message
    tvText.setTextColor(Color.parseColor("#000000"))
    tvText.textSize = 20.toFloat()
    tvText.layoutParams = llParam

    ll.addView(progressBar)
    ll.addView(tvText)

    val builder = AlertDialog.Builder(context)
    builder.setCancelable(true)
    builder.setView(ll)

    val dialog = builder.create()
    val window = dialog.window
    if (window != null) {
        val layoutParams = WindowManager.LayoutParams()
        layoutParams.copyFrom(dialog.window?.attributes)
        layoutParams.width = LinearLayout.LayoutParams.WRAP_CONTENT
        layoutParams.height = LinearLayout.LayoutParams.WRAP_CONTENT
                dialog.window?.attributes = layoutParams
    }
    return dialog
}

Stosowanie:

val dialog = setProgressDialog(this, "Loading..")
dialog.show()

Wynik:

Jak wspomniano na stronie dokumentacji, alternatywą jest ProgressBar . ProgressDialogWygląd można replikować, umieszczając plik ProgressBarw AlertDialog.

Nadal możesz go używać, ale Android nie chce, abyś go używał, dlatego jest przestarzały. Dlatego powinieneś rozważyć rozwiązanie swojego problemu w inny sposób, na przykład osadzenie a ProgressBarw swoim Layout.

ProgressDialog został uznany za przestarzały na poziomie API 26.

"Deprecated" odnosi się do funkcji lub elementów, które są w trakcie zastępowania nowszymi.

ProgressDialog to modalne okno dialogowe, które uniemożliwia użytkownikowi interakcję z aplikacją. Zamiast korzystać z tej klasy, należy użyć wskaźnika postępu, takiego jak ProgressBar, który można osadzić w interfejsie aplikacji.

Korzyść

Osobiście powiedziałbym, że ProgressBarma przewagę nad tymi dwoma. ProgressBarto element interfejsu użytkownika, który wskazuje postęp operacji. Wyświetlaj paski postępu użytkownikowi bez przerywania pracy . Pokaż pasek postępu w interfejsie aplikacji.

Używam DelayedProgressDialog z https://github.com/Q115/DelayedProgressDialog Robi to samo co ProgressDialog z dodatkową korzyścią opóźnienia, jeśli to konieczne.

Korzystanie z niego jest podobne do ProgressDialog przed Androidem O:

DelayedProgressDialog progressDialog = new DelayedProgressDialog();
progressDialog.show(getSupportFragmentManager(), "tag");

Możesz skorzystać z tej klasy, którą napisałem. Oferuje tylko podstawowe funkcje. Jeśli potrzebujesz w pełni funkcjonalnego programu ProgressDialog, skorzystaj z tej lekkiej biblioteki .

Konfiguracja stopniowa

Dodaj następującą zależność do module / build.gradle:

compile 'com.lmntrx.android.library.livin.missme:missme:0.1.5'

Jak tego użyć?

Użycie jest podobne do oryginalnego ProgressDialog

ProgressDialog progressDialog = new 
progressDialog(YourActivity.this);
progressDialog.setMessage("Please wait");
progressDialog.setCancelable(false);
progressDialog.show();
progressDialog.dismiss();

NB : Musisz zastąpić aktywnośćonBackPressed()

Implementacja Java8:

@Override
public void onBackPressed() {
    progressDialog.onBackPressed(
            () -> {
                super.onBackPressed();
                return null;
            }
    );
}

Realizacja Kotlin:

override fun onBackPressed() {
   progressDialog.onBackPressed { super.onBackPressed() }
}

• Pełną implementację można znaleźć w Przykładowej aplikacji
• Pełna dokumentacja znajduje się tutaj

Może ten przewodnik może ci pomóc.

Zwykle wolę tworzyć niestandardowe AlertDialogs ze wskaźnikami. Rozwiązuje takie problemy, jak dostosowywanie widoku aplikacji.

Może to pomóc innym ludziom.

Wiele popularnych aplikacji ma różne podejście do pokazywania postępów takich jak żądanie sieciowe, ładowanie plików itp. Ładowanie spinner nie pokazuje, ile treści zostało załadowane lub pozostało do załadowania. Jest okres niepewności, który jest zły w perspektywie UI / UX. Wiele popularnych aplikacji (Facebook, Linkedin itp.) Rozwiązało ten problem, wyświetlając najpierw interfejs użytkownika z odkrytymi kośćmi. Następnie ładowana zawartość jest stopniowo wypełniana na ekranie.

Użyłem migotania do moich aplikacji, aby rozwiązać ten problem.

Jest dobry artykuł na ten temat, który będzie korzystny dla innych ludzi

W oknie dialogowym postępu użytkownik nie może wykonywać żadnej pracy. Wszystkie procesy w tle są zatrzymywane podczas okna dialogowego postępu. Dlatego wskazane jest, aby pasek postępu użytkownika zamiast okna postępu.

Możesz użyć SpotDialog , korzystając z biblioteki wasabeef pełny samouczek można znaleźć pod następującym linkiem:

Przykład SpotsDialog w systemie Android