1 /*
2  * Copyright (C) 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.tv.settings.connectivity;
18 
19 import android.content.Context;
20 import android.net.ConnectivityManager;
21 import android.net.Network;
22 import android.os.Handler;
23 import android.os.Looper;
24 import android.os.Message;
25 
26 import androidx.annotation.NonNull;
27 import androidx.lifecycle.Lifecycle;
28 import androidx.lifecycle.LifecycleObserver;
29 import androidx.lifecycle.OnLifecycleEvent;
30 
31 /**
32  * Listens for changes in internet connectivity without using WifiTracker to avoid wifi scans.
33  */
34 public class ConnectivityListenerLite implements LifecycleObserver {
35     private static final int CONNECTIVITY_CHANGE = 0;
36     private final ConnectivityManager mConnectivityManager;
37     private final ActiveNetworkProvider mActiveNetworkProvider;
38     private Listener mListener;
39 
40     private final Handler mHandler;
41     private final ConnectivityManager.NetworkCallback mNetworkCallback;
42 
43     private final Lifecycle mLifecycle;
44 
ConnectivityListenerLite(Context context, Listener listener, Lifecycle lifecycle)45     public ConnectivityListenerLite(Context context, Listener listener, Lifecycle lifecycle) {
46         mConnectivityManager = context.getSystemService(ConnectivityManager.class);
47         mActiveNetworkProvider = new ActiveNetworkProvider(context);
48         mListener = listener;
49         mHandler = new Handler(Looper.getMainLooper()) {
50             @Override
51             public void handleMessage(@NonNull Message msg) {
52                 if (msg.what == CONNECTIVITY_CHANGE) {
53                     handleConnectivityChange();
54                 }
55             }
56         };
57         mNetworkCallback = new DefaultNetworkCallback(mHandler);
58         mLifecycle = lifecycle;
59         mLifecycle.addObserver(this);
60     }
61 
handleConnectivityChange()62     public void handleConnectivityChange() {
63         mActiveNetworkProvider.updateActiveNetwork();
64         mListener.onConnectivityChange(mActiveNetworkProvider);
65     }
66 
67     @OnLifecycleEvent(Lifecycle.Event.ON_START)
registerNetworkCallback()68     private void registerNetworkCallback() {
69         mConnectivityManager.registerDefaultNetworkCallback(mNetworkCallback);
70     }
71 
72     @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
unregisterNetworkCallback()73     private void unregisterNetworkCallback() {
74         mConnectivityManager.unregisterNetworkCallback(mNetworkCallback);
75     }
76 
77     @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
onDestroy()78     public void onDestroy() {
79         mHandler.removeCallbacksAndMessages(null);
80         mLifecycle.removeObserver(this);
81         mListener = null;
82     }
83 
setListener(Listener listener)84     public void setListener(Listener listener) {
85         this.mListener = listener;
86     }
87 
88     public interface Listener {
onConnectivityChange(ActiveNetworkProvider activeNetworkProvider)89         void onConnectivityChange(ActiveNetworkProvider activeNetworkProvider);
90     }
91 
92     private static class DefaultNetworkCallback extends ConnectivityManager.NetworkCallback {
93         private static final int DELAY = 100;
94         private final Handler mHandler;
95 
DefaultNetworkCallback(Handler handler)96         private DefaultNetworkCallback(Handler handler) {
97             this.mHandler = handler;
98         }
99 
100         @Override
onAvailable(@onNull Network network)101         public void onAvailable(@NonNull Network network) {
102             super.onAvailable(network);
103             mHandler.removeMessages(CONNECTIVITY_CHANGE);
104             mHandler.sendEmptyMessageDelayed(CONNECTIVITY_CHANGE, DELAY);
105         }
106 
107         @Override
onLost(@onNull Network network)108         public void onLost(@NonNull Network network) {
109             super.onLost(network);
110             mHandler.removeMessages(CONNECTIVITY_CHANGE);
111             mHandler.sendEmptyMessageDelayed(CONNECTIVITY_CHANGE, DELAY);
112         }
113     }
114 }
115