Android 若应用程序是在脱机模式下启动的，则在连接到internet后，进度对话框应隐藏

如果我的应用程序在脱机模式下启动，并且在我打开wifi/移动数据后，我的进度对话框应该隐藏并显示snackbar，而无需重新启动应用程序

我举了一个例子：

但当我打开或关闭互联网时，若不再次启动应用程序，它不会立即生效

代码：

package com.jimmytrivedi.lapitchat.Activity；
导入android.app.ProgressDialog；
导入android.content.Intent；
导入android.graphics.Color；
导入android.os.Bundle；
导入android.support.annotation.NonNull；
导入android.support.design.widget.Snackbar；
导入android.support.v7.app.AppActivity；
导入android.util.Log；
导入android.view.view；
导入android.widget.Button；
导入android.widget.RelativeLayout；
导入android.widget.TextView；
导入android.widget.Toast；
导入com.facebook.AccessToken；
导入com.facebook.CallbackManager；
导入com.facebook.facebook回调；
导入com.facebook.facebook异常；
导入com.facebook.login.LoginResult；
导入com.facebook.login.widget.LoginButton；
导入com.google.android.gms.tasks.OnCompleteListener；
导入com.google.android.gms.tasks.Task；
导入com.google.firebase.auth.AuthCredential；
导入com.google.firebase.auth.AuthResult；
导入com.google.firebase.auth.FacebookAuthProvider；
导入com.google.firebase.auth.FirebaseAuth；
导入com.google.firebase.auth.FirebaseUser；
导入com.jimmytrivedi.lapitchat.Application.lapitchat；
导入com.jimmytrivedi.lapitchat.Interface.ConnectivityReceiverListener；
导入com.jimmytrivedi.lapitchat.R；
导入com.jimmytrivedi.lapitchat.Receiver.ConnectivityReceiver；
导入butterknife.BindView；
进口毛刀，毛刀；
公共类StartActivity扩展了AppCompativeActivity实现了View.OnClickListener、ConnectivityReceiveListener{
私有静态最终字符串标记=StartActivity.class.getName（）；
@BindView（R.id.signup）
按钮注册；
@BindView（R.id.login）
按钮登录；
@BindView（R.id.phoneAuth）
按钮phoneAuth；
@BindView（R.id.U按钮）
登录按钮facebookButton；
@BindView（R.id.relative_布局）
相对的相对的；
私有CallbackManager-mCallbackManager；
私人消防队；
私有进程对话；
私有FirebaseUser当前用户；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_start）；
把（这个）绑起来；
init（）；
检查连接（）；
setClickListener（）；
点击Facebook（）；
}
私有void clickOnFacebook（）{
mCallbackManager=CallbackManager.Factory.create（）；
setReadPermissions（“电子邮件”、“公共档案”）；
registerCallback（mCallbackManager，new FacebookCallback（））{
@凌驾
成功时公共无效（LoginResult LoginResult）{
Log.e（标签“Facebook:onSuccess:+loginResult”）；
handleFacebookAccessToken（loginResult.getAccessToken（））；
}
@凌驾
公开作废{
Log.e（标签“facebook:onCancel”）；
}
@凌驾
public void onError（facebook异常错误）{
Log.e（标签“facebook:onError”，错误）；
}
});
}
私有void setClickListener（）{
signup.setOnClickListener（this）；
login.setOnClickListener（this）；
phoneAuth.setOnClickListener（此）；
}
公共void init（）{
progressDialog=新建progressDialog（此）；
mAuth=FirebaseAuth.getInstance（）；
}
私有布尔检查连接（）{
布尔值isConnected=ConnectivityReceiver.isConnected（）；
显示网络状态（已连接）；
返回true；
}
@凌驾
public void onStart（）{
super.onStart（）；
currentUser=mAuth.getCurrentUser（）；
如果（currentUser！=null）{
updateUI（）；
}
}
私有void updateUI（）{
startActivity（新意图（startActivity.this，MainActivity.class））；
}
@凌驾
受保护的void onActivityResult（int请求代码、int结果代码、意图数据）{
super.onActivityResult（请求代码、结果代码、数据）；
//将活动结果传回Facebook SDK
onActivityResult（请求代码、结果代码、数据）；
}
私有无效handleFacebookAccessToken（AccessToken令牌）{
AuthCredential credential=FacebookAuthProvider.getCredential（token.getToken（））；
mAuth.SIGNWITH凭证（凭证）
.addOnCompleteListener（这是新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
FirebaseUser=mAuth.getCurrentUser（）；
updateUI（）；
}否则{
Toast.makeText（StartActivity.this，“身份验证失败”，
吐司。长度（短）。show（）；
}
}
});
}
@凌驾
公共void onClick（视图）{
int id=view.getId（）；
意图；
开关（id）{
案例R.id.注册：
intent=新的intent（StartActivity.this、RegisterActivity.class）；
星触觉（意向）；
打破
案例R.id.login：
意图=新意图（StartActivity.this、LoginActivity.class）；
星触觉（意向）；
打破
案例R.id.phoneAuth：
intent=新的intent（StartActivity.this、PhoneAuthActivity.class）；
星触觉（意向）；
打破
}
}
P
package com.jimmytrivedi.lapitchat.Activity;

import android.app.ProgressDialog;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.facebook.AccessToken;
import com.facebook.CallbackManager;
import com.facebook.FacebookCallback;
import com.facebook.FacebookException;
import com.facebook.login.LoginResult;
import com.facebook.login.widget.LoginButton;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.auth.AuthCredential;
import com.google.firebase.auth.AuthResult;
import com.google.firebase.auth.FacebookAuthProvider;
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;
import com.jimmytrivedi.lapitchat.Application.LapitChat;
import com.jimmytrivedi.lapitchat.Interface.ConnectivityReceiverListener;
import com.jimmytrivedi.lapitchat.R;
import com.jimmytrivedi.lapitchat.Receiver.ConnectivityReceiver;

import butterknife.BindView;
import butterknife.ButterKnife;

public class StartActivity extends AppCompatActivity implements View.OnClickListener, ConnectivityReceiverListener {

    private static final String TAG = StartActivity.class.getName();

    @BindView(R.id.signup)
    Button signup;
    @BindView(R.id.login)
    Button login;
    @BindView(R.id.phoneAuth)
    Button phoneAuth;
    @BindView(R.id.facebook_button)
    LoginButton facebookButton;
    @BindView(R.id.relative_layout)
    RelativeLayout relativeLayout;

    private CallbackManager mCallbackManager;
    private FirebaseAuth mAuth;
    private ProgressDialog progressDialog;
    private FirebaseUser currentUser;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_start);
        ButterKnife.bind(this);

        init();
        checkConnection();
        setClickListener();
        clickOnFacebook();

    }

    private void clickOnFacebook() {
        mCallbackManager = CallbackManager.Factory.create();
        facebookButton.setReadPermissions("email", "public_profile");
        facebookButton.registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
            @Override
            public void onSuccess(LoginResult loginResult) {
                Log.e(TAG, "Facebook:onSuccess: " + loginResult);
                handleFacebookAccessToken(loginResult.getAccessToken());
            }

            @Override
            public void onCancel() {
                Log.e(TAG, "facebook:onCancel");
            }

            @Override
            public void onError(FacebookException error) {
                Log.e(TAG, "facebook:onError", error);
            }
        });
    }

    private void setClickListener() {
        signup.setOnClickListener(this);
        login.setOnClickListener(this);
        phoneAuth.setOnClickListener(this);
    }

    public void init() {
        progressDialog = new ProgressDialog(this);
        mAuth = FirebaseAuth.getInstance();
    }


    private boolean checkConnection() {
        boolean isConnected = ConnectivityReceiver.isConnected();
        showNetworkStatus(isConnected);
        return true;
    }

    @Override
    public void onStart() {
        super.onStart();
        currentUser = mAuth.getCurrentUser();
        if (currentUser != null) {
            updateUI();
        }
    }

    private void updateUI() {
        startActivity(new Intent(StartActivity.this, MainActivity.class));
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // Pass the activity result back to the Facebook SDK
        mCallbackManager.onActivityResult(requestCode, resultCode, data);
    }

    private void handleFacebookAccessToken(AccessToken token) {
        AuthCredential credential = FacebookAuthProvider.getCredential(token.getToken());
        mAuth.signInWithCredential(credential)
                .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        if (task.isSuccessful()) {
                            FirebaseUser user = mAuth.getCurrentUser();
                            updateUI();
                        } else {
                            Toast.makeText(StartActivity.this, "Authentication failed.",
                                    Toast.LENGTH_SHORT).show();
                        }

                    }
                });
    }

    @Override
    public void onClick(View view) {
        int id = view.getId();
        Intent intent;
        switch (id) {
            case R.id.signup:
                intent = new Intent(StartActivity.this, RegisterActivity.class);
                startActivity(intent);
                break;

            case R.id.login:
                intent = new Intent(StartActivity.this, LoginActivity.class);
                startActivity(intent);
                break;

            case R.id.phoneAuth:
                intent = new Intent(StartActivity.this, PhoneAuthActivity.class);
                startActivity(intent);
                break;
        }
    }

    private void showNetworkStatus(boolean isConnected) {
        String message = "";
        int color = 0;
        if (isConnected) {
            progressDialog.dismiss();
            message = "Connected to Internet";
            color = Color.WHITE;
            Snackbar snackbar = Snackbar
                    .make(relativeLayout, message, Snackbar.LENGTH_LONG);

            View sbView = snackbar.getView();
            TextView textView = sbView.findViewById(android.support.design.R.id.snackbar_text);
            textView.setTextColor(color);
            snackbar.show();
        } else {
            progressDialog.setTitle(getResources().getString(R.string.check_connection));
            progressDialog.setMessage(getResources().getString(R.string.wait));
            progressDialog.setCancelable(false);
            progressDialog.show();
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        LapitChat.getInstance().setConnectivityListener(this);
    }

    @Override
    public void onNetworkConnectionChanged(boolean isConnected) {
        showNetworkStatus(isConnected);
    }
}