O ProgressDialog foi descontinuado. Qual é a alternativa a ser usada?

Eu vim para ver que ProgressDialogagora está obsoleto. O que seria um alternativo para usar no lugar disso, além de ProgressBar? Estou usando a versão 2.3.3 do android studio.

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

Sim, API level 26está obsoleto. Em vez disso, você pode usar progressBar.

Para criá-lo programaticamente:

Primeiro, obtenha uma referência ao layout raiz

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

ou

RelativeLayout layout = findViewById(this);

Em seguida, adicione a barra de progresso

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);

Para mostrar a barra de progresso

progressBar.setVisibility(View.VISIBLE);

Para ocultar a barra de progresso

progressBar.setVisibility(View.GONE);

Para desativar a interação do usuário, você só precisa adicionar o seguinte código

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

Para recuperar a interação do usuário, basta adicionar o seguinte código

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

Apenas para referência futura, altere android.R.attr.progressBarStyleSmallpara android.R.attr.progressBarStyleHorizontal.

O código abaixo funciona apenas acima API level 21

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

Para criá-lo via 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"/>

Na sua atividade

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

Mostrar / ocultar a barra de progresso é o mesmo

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

Aqui está uma imagem de exemplo de como seria:

Para mais detalhes:
1. Referência um
2. Referência dois

você pode usar AlertDialogcomo se ProgressDialogrefere abaixo código para o ProgressDialog. Essa função você precisa chamar sempre que mostrar uma caixa de diálogo de progresso.

Código:

    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);
    }
}

Resultado:

Esta classe foi descontinuada no nível 26 da API. ProgressDialog é uma caixa de diálogo modal, que impede o usuário de interagir com o aplicativo. Em vez de usar essa classe, você deve usar um indicador de progresso como ProgressBar, que pode ser incorporado na interface do usuário do seu aplicativo. Como alternativa, você pode usar uma notificação para informar o usuário sobre o progresso da tarefa. ligação

Foi descontinuado Android Odevido ao Googlenovo padrão de interface do usuário

Você pode simplesmente criar uma interface xml para sua barra de progresso e passá-la como uma exibição para um AlertDialog, depois mostrar ou descartar a caixa de diálogo a qualquer momento.

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>

O código do código que exibe a caixa de diálogo de progresso. Basta copiar esse código e colá-lo em seu fragmento.

  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();
        }

Em seguida, basta chamar o método sempre que desejar mostrar o diálogo de progresso e passar verdadeiro como argumento para mostrá-lo ou falso para descartar a caixa de diálogo.

O ProgressBar é muito simples e fácil de usar, pretendo fazer o mesmo que o simples diálogo de progresso. O primeiro passo é criar o layout em xml da caixa de diálogo que deseja mostrar, digamos que o nome desse layout

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>

O próximo passo é criar o AlertDialog que mostrará esse layout com o 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();

agora tudo o que resta é mostrar e ocultar esse diálogo em nossos eventos de clique como este

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

e é isso, deve funcionar, como você pode ver, é muito simples e fácil de implementar ProgressBar em vez de ProgressDialog. agora você pode mostrar / descartar esta caixa de diálogo no Handler ou no ASyncTask, depende de sua necessidade

Sim, o ProgressDialog está obsoleto, mas o Dialog não está.

Você pode inflar seu próprio arquivo XML (contendo uma barra de progresso e um texto carregado) em seu objeto de diálogo e depois exibi-lo ou ocultá-lo usando as funções show()e dismiss(). Aqui está um exemplo (Kotlin):

Classe 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>

No seu código : façavar dialog = ProgressDialog.progressDialog(context)

Mostrar: dialog.show()

Esconder: dialog.dismiss()

Bem, se você realmente quer ir contra a vontade deles, ainda pode usar o Sweet Alert Dialog ou criar um por conta própria.

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>

Código 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 é a melhor alternativa para ProgressDialog. Um elemento da interface do usuário que indica o progresso de uma operação.

Para mais informações, consulte este documento do Google: https://developer.android.com/reference/android/widget/ProgressBar.html

Você não precisa importar nenhuma biblioteca personalizada.

Eu prefiro usar o moderno, AlertDialogentão esta é a versão do Kotlin para a ótima resposta postada por Kishan Donga nesta página.

Código 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
}

Uso:

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

Resultado:

Conforme mencionado na página de documentação, a alternativa é ProgressBar . ProgressDialogA aparência de pode ser replicada colocando um ProgressBarem um AlertDialog.

Você ainda pode usá-lo, mas o Android não deseja que você o use, é por isso que está obsoleto. Portanto, considere resolver seu problema de outra maneira, como incorporar um ProgressBarno seu Layout.

ProgressDialog foi descontinuado no nível da API 26.

"Deprecated" refere-se a funções ou elementos que estão em processo de substituição por outros mais novos.

ProgressDialog é uma caixa de diálogo modal, que impede o usuário de interagir com o aplicativo. Em vez de usar esta classe, você deve usar um indicador de progresso como ProgressBar, que pode ser incorporado na interface do usuário do seu aplicativo.

Vantagem

Eu diria pessoalmente que ProgressBartem vantagem sobre os dois. ProgressBaré um elemento da interface do usuário que indica o progresso de uma operação. Exibir barras de progresso para um usuário de maneira ininterrupta . Mostre a barra de progresso na interface do usuário do seu aplicativo.

Uso DelayedProgressDialog em https://github.com/Q115/DelayedProgressDialog Ele faz o mesmo que ProgressDialog com o benefício adicional de um atraso, se necessário.

Usá-lo é semelhante ao ProgressDialog antes do Android O:

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

Você pode usar essa classe que escrevi. Ele oferece apenas as funções básicas. Se você deseja um ProgressDialog totalmente funcional, use esta biblioteca leve .

Configuração Gradle

Adicione a seguinte dependência ao module / build.gradle:

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

Como usá-lo?

O uso é semelhante ao ProgressDialog original

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

NB : Você deve substituir as atividadesonBackPressed()

Implementação do Java8:

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

Implementação Kotlin:

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

• Consulte o aplicativo de exemplo para obter a implementação completa
• A documentação completa pode ser encontrada aqui

Talvez este guia possa ajudá-lo.

Normalmente, prefiro criar AlertDialogs personalizados com indicadores. Resolve problemas como a personalização da visualização do aplicativo.

Pode ajudar a outras pessoas.

Muitos aplicativos populares têm uma abordagem diferente para mostrar o progresso de qualquer solicitação de rede, carregamento de arquivos etc. O carregamento do spinner não mostra a quantidade de conteúdo carregado ou restante a ser carregado. Há um período de incerteza que é ruim na perspectiva da UI / UX. Muitos aplicativos populares (Facebook, Linkedin etc.) resolveram esse problema, mostrando primeiro a interface do usuário básica. Em seguida, o conteúdo carregado é preenchido gradualmente na tela.

Eu usei o brilho nos meus aplicativos para resolver esse problema.

Existe um bom artigo sobre isso que será benéfico para outras pessoas

Na caixa de diálogo de progresso, o usuário não pode fazer nenhum tipo de trabalho. Todos os processos em segundo plano são interrompidos durante o diálogo de progresso. Portanto, é aconselhável usar a barra de progresso em vez da caixa de diálogo de progresso.

Você pode usar o SpotDialog usando a biblioteca wasabeef você pode encontrar o tutorial completo no seguinte link:

Exemplo de SpotsDialog no Android