Fatal编程技术网
  • android/
  • Android 如果没有internet连接，则显示snackbar

Android 如果没有internet连接，则显示snackbar

android

Android 如果没有internet连接，则显示snackbar,android,Android,这里我有一个splash活动，我希望它在找不到internet连接时生成snackbar按摩，并且在其中有一个重试选项…当单击重试按钮时，再次检查internet连接，然后转到下一个活动…帮助我 package com.apkglobal.pocket; import android.content.Intent; import android.os.Handler; import android.support.v7.app.AppCompatActivity; import android

这里我有一个splash活动，我希望它在找不到internet连接时生成snackbar按摩，并且在其中有一个重试选项…当单击重试按钮时，再次检查internet连接，然后转到下一个活动…帮助我

package com.apkglobal.pocket;

import android.content.Intent;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.WindowManager;

import com.apkglobal.pocket.R;

public class SplashActivity extends AppCompatActivity {
    private static int SPLASH_TIME_OUT=2000;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_splash);

        getSupportActionBar().hide();
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);

        new Handler().postDelayed(new Runnable(){
            @Override
            public void run(){
                Intent i= new Intent(SplashActivity.this,NavigationActivity.class);
                startActivity(i);
                finish();
            }
        }, SPLASH_TIME_OUT);
    }
}
试试这个

if(!isConnectedToInternet()){
//Show snackbar..please tell me you know how to show a snackbar
}

private boolean isConnectedToInternet(Context context) {
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo netInfo = cm.getActiveNetworkInfo();
        return netInfo != null && netInfo.isConnectedOrConnecting();
    }
在AndroidManifest.xml中添加此权限

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
试试这个

if(!isConnectedToInternet()){
//Show snackbar..please tell me you know how to show a snackbar
}

private boolean isConnectedToInternet(Context context) {
        ConnectivityManager cm =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo netInfo = cm.getActiveNetworkInfo();
        return netInfo != null && netInfo.isConnectedOrConnecting();
    }
在AndroidManifest.xml中添加此权限

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
这里有一个简单的解决方案，用于ping服务器，然后在主线程上返回结果

    private void showSnackIfOffline(){
    final boolean online = isOnline();
    runOnUiThread(new TimerTask() { //must run on main thread to update UI (show Snackbar), can be used only in Activity (FragmentActivity, AppCompatActivity...)
        @Override
        public void run() {
            if(!online)
                Snackbar.make(findViewById(android.R.id.content), "Sorry, you're offline", Snackbar.LENGTH_SHORT);
            else{
                /*
                    Your code here if user is online
                */
            }
        }
    });
}

private boolean isOnline(){
    try {
        return Runtime.getRuntime().exec("/system/bin/ping -c 1 8.8.8.8").waitFor() == 0; //  "8.8.8.8" is the server to ping
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}
这里有一个简单的解决方案，用于ping服务器，然后在主线程上返回结果

    private void showSnackIfOffline(){
    final boolean online = isOnline();
    runOnUiThread(new TimerTask() { //must run on main thread to update UI (show Snackbar), can be used only in Activity (FragmentActivity, AppCompatActivity...)
        @Override
        public void run() {
            if(!online)
                Snackbar.make(findViewById(android.R.id.content), "Sorry, you're offline", Snackbar.LENGTH_SHORT);
            else{
                /*
                    Your code here if user is online
                */
            }
        }
    });
}

private boolean isOnline(){
    try {
        return Runtime.getRuntime().exec("/system/bin/ping -c 1 8.8.8.8").waitFor() == 0; //  "8.8.8.8" is the server to ping
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}
  • 试试这个希望对你有帮助
  • 为Snackbar创建方法并在此处调用
    • 快乐编码：）

  • 试试这个希望对你有帮助
  • 为Snackbar创建方法并在此处调用
    • 快乐编码：）我的示例实现，Kotlin中带有Snackbar的网络状态通知。也许它会帮助别人。我向听众介绍了网络的状态。Snackbar会在任何屏幕上弹出

    interface INetworkAvailabilityNotification {
    fun init()
}

class NetworkAvailabilityNotificationImpl(
        val context: Context,
        private val networkStateProvider: INetworkStateProvider,
        resourcesInteractor: IResourcesInteractor) : INetworkAvailabilityNotification {

private var weekReferenceActivity: WeakReference<Activity>? = null
private var snackbar: Snackbar? = null
private val networkUnavailableText: String by lazy { resourcesInteractor.getString(R.string.network_unavailable_error) }

override fun init() {
    initActivityCallback()
    initOnlineListener()
}

private fun showSnackbar(message: String) {
    initSnackBar()
    setText(message)
    snackbar?.show()
}

private fun setViewParams() {
    snackbar?.let {
        val layoutParams =
                (it.view.layoutParams as FrameLayout.LayoutParams)
                        .also { lp -> lp.setMargins(0, 0, 0, 0) }
        it.view.setBackgroundColor(Color.BLACK)
        it.view.layoutParams = layoutParams
        it.view.alpha = 0.90f
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            it.view.elevation = 0f
        }
    }
}

private fun initActivityCallback() = (context as? Application)?.registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacksImpl() {
    override fun onActivityResumed(activity: Activity?) {
        activity?.let { weekReferenceActivity = WeakReference(activity) }
    }
})

private fun initSnackBar() = weekReferenceActivity?.get()?.findViewById<View>(android.R.id.content)?.let { view ->
    if (weekReferenceActivity?.get() is AppCompatActivity) {
        snackbar = Snackbar.make(view, "", Snackbar.LENGTH_INDEFINITE).setBehavior(NoSwipeBehavior())
        setViewParams()
    }
}

private fun initOnlineListener() {
    networkStateProvider.isOnline.observe { isOnline ->
        if (isOnline) snackbar?.dismiss() else showSnackbar(networkUnavailableText)
    }
}

private fun setText(message: String) {
    val spannableString = SpannableString(message).apply {
        setSpan(ForegroundColorSpan(ContextCompat.getColor(context, R.color.white)), 0, message.length, 0)
    }
    snackbar?.setText(spannableString)
}
}

internal class NoSwipeBehavior : BaseTransientBottomBar.Behavior() {
    override fun canSwipeDismissView(child: View): Boolean = false
}

open class ActivityLifecycleCallbacksImpl : Application.ActivityLifecycleCallbacks {
    override fun onActivityPaused(activity: Activity?) {}
    override fun onActivityResumed(activity: Activity?) {}
    override fun onActivityStarted(activity: Activity?) {}
    override fun onActivityDestroyed(activity: Activity?) {}
    override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {}
    override fun onActivityStopped(activity: Activity?) {}
    override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {}

}

    接口INetworkAvailabilityNotification{
fun init（）
}
类NetworkAvailabilityNotificationImpl(
val context:context，
专用val networkStateProvider:INetworkStateProvider，
ResourcesInTerractor:iResourcesInTerractor）：InetworkAvailability通知{
私有变量weekReferenceActivity:WeakReference？=null
私有变量snackbar:snackbar？=null
private val networkUnavailableText:lazy{resourcesInteractor.getString（R.String.network_unavailable_error）}的字符串
重写fun init（）{
initActivityCallback（）
initOnlineListener（）
}
私人娱乐showSnackbar（消息：String）{
initSnackBar（）
setText（消息）
snackbar？.show（）
}
private fun setViewParams（）{
斯奈克巴？，让我来{
val布局参数=
（it.view.layoutParams作为FrameLayout.layoutParams）
.ALL{lp->lp.setMargins（0,0,0,0）}
it.view.setBackgroundColor（Color.BLACK）
it.view.layoutParams=layoutParams
it.view.alpha=0.90f
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.LOLLIPOP）{
it.view.elevation=0f
}
}
}
private fun initActivityCallback（）=（作为应用程序的上下文）？。registerActivityLifecycleCallbacks（对象：ActivityLifeCycleCallbackSiml（）{
覆盖活动上的乐趣已使用（活动：活动？）{
活动？.let{weekReferenceActivity=WeakReference（活动）}
}
})
private fun initSnackBar（）=weekReferenceActivity？.get（）？.findViewById（android.R.id.content）？.let{view->
如果（weekReferenceActivity？.get（）为AppCompatiActivity）{
snackbar=snackbar.make（视图“”，snackbar.LENGTH\u不确定）。setBehavior（nosweepbeavior（））
setViewParams（）
}
}
private fun initOnlineListener（）{
networkStateProvider.isOnline.observe{isOnline->
if（isOnline）snackbar？.disclose（）否则显示snackbar（networkUnavailableText）
}
}
private fun setText（消息：字符串）{
val spannableString=spannableString（消息）。应用{
setSpan（ForegroundColorSpan（ContextCompat.getColor（context，R.color.white）），0，message.length，0）
}
snackbar？.setText（spannableString）
}
}
内部类NoSwipeBehavior:BaseTransientBottomBar.Behavior（）{
覆盖视图（子：视图）：布尔值=false
}
开放类ActivityLifecycleCallbacksImpl:Application.ActivityLifecycleCallbacks{
覆盖活动中的乐趣（活动：活动？{}
在ActivityResumed上覆盖乐趣（活动：活动？{}
覆盖活动启动时的乐趣（活动：活动？{}
在ActivityDestroyed上覆盖乐趣（活动：活动？{}
覆盖ActivitySaveInstanceState上的乐趣（活动：活动？，超出状态：捆绑？{}
在ActivityStopped上覆盖乐趣（活动：活动？{}
重写ActivityCreated上的乐趣（activity:activity？，savedInstanceState:Bundle？{}
}
    网络状态类

    interface INetworkStateProvider {
    val stateLiveData: LiveData<SealedNetworkState>
    val isOnline: LiveData<Boolean>
}

class NetworkStateProviderImpl(private val context: Context) : INetworkStateProvider {

    private companion object {
        const val CONNECTIVITY_CHANGE = "android.net.conn.CONNECTIVITY_CHANGE"
        const val WIFI_STATE_CHANGED = "android.net.wifi.WIFI_STATE_CHANGED"
    }

    private val connectivityManager: ConnectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    private val broadcastReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) = this@NetworkStateProviderImpl.onReceive()
    }
    override val stateLiveData: MutableLiveData<SealedNetworkState> = object : MutableLiveData<SealedNetworkState>() {
        override fun onActive() = registerBroadcastReceiver()
        override fun onInactive() = unregisterBroadcastReceiver()
    }
    override val isOnline: MutableLiveData<Boolean> = stateLiveData.map {
        connectivityManager.activeNetworkInfo?.isConnected == true
    }.distinctUntilChanged()


    private fun registerBroadcastReceiver() {
        context.registerReceiver(broadcastReceiver, IntentFilter().apply {
            addAction(CONNECTIVITY_CHANGE)
            addAction(WIFI_STATE_CHANGED)
        })
    }

    private fun unregisterBroadcastReceiver() = context.unregisterReceiver(broadcastReceiver)

    private fun getConnectivityStatus(): SealedNetworkState = if (connectivityManager.activeNetworkInfo?.isConnected == true) {
        when (connectivityManager.activeNetworkInfo?.type) {
            ConnectivityManager.TYPE_WIFI -> SealedNetworkState.NetworkWiFi
            ConnectivityManager.TYPE_MOBILE -> SealedNetworkState.NetworkMobile
            else -> SealedNetworkState.NetworkOther
        }
    } else SealedNetworkState.NetworkNone

    private fun onReceive() = with(getConnectivityStatus()) {
        if (this != stateLiveData.value) stateLiveData.postValue(this)
    }
}

sealed class SealedNetworkState {
    object NetworkWiFi : SealedNetworkState()
    object NetworkMobile : SealedNetworkState()
    object NetworkOther : SealedNetworkState()
    object NetworkNone : SealedNetworkState()
}

    接口INetworkStateProvider{
val stateLiveData:LiveData
val isOnline:LiveData
}
类NetworkStateProviderImpl（专用val上下文：上下文）：INetworkStateProvider{
私人伴侣对象{
const val CONNECTIVITY_CHANGE=“android.net.conn.CONNECTIVITY_CHANGE”
const val WIFI_STATE_CHANGED=“android.net.WIFI.WIFI_STATE_CHANGED”
}
私有val connectivityManager:connectivityManager=context.getSystemService（context.CONNECTIVITY_服务）作为connectivityManager
private val broadcastReceiver=对象：broadcastReceiver（）{
覆盖接收（上下文：上下文？，意图：意图？=this@NetworkStateProviderImpl.onReceive()
}
重写val stateLiveData:MutableLiveData=object:MutableLiveData（）{
重写fun onActive（）=registerBroadcastReceiver（）
override fun OnInActivity（）=unregisterBroadcastReceiver（）
}
覆盖val isOnline:MutableLiveData=stateLiveData.map{
ConnectionManager.activeNetworkInfo？.isConnected==true
}.distinctUntilChanged（）
私人娱乐登记处Roadcastereceiver（）{
registerReceiver（broadcastReceiver，IntentFilter（）.apply{
添加操作（连接更改）
添加操作（WIFI状态已更改）
})
}
private fun unregisterBroadcastReceiver（）=上下文。unregisterReceiver（broadcastReceiver）
private fun GetConnectionVityStatus（）：SealedNetworkState=if（connectivityManager.activeNetworkInfo？.isConnected==true）{
何时（connectivityManager.activeNetworkInfo？.type）{
ConnectivityManager.TYPE_WIFI->SealedNetworkState.NetworkWiFi
ConnectivityManager.TYPE_MOBILE->SealedNetworkState.NetworkMobile
else->SealedNetworkState.NetworkOther
}
}else密封的NetworkState.NetworkNone
private fun onReceive（）=带（g）

    private fun showNoNetSnackbar() {
        val snack = Snackbar.make(rootView, "No Internet!", Snackbar.LENGTH_LONG) // replace root view with your view Id
        snack.setAction("Settings") {
            startActivity(Intent(Settings.ACTION_WIFI_SETTINGS))
        }
        snack.show()
    }