1 /*
2  * Copyright (C) 2014 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.content.Intent;
21 import android.net.wifi.WifiConfiguration;
22 import android.os.Bundle;
23 import android.os.UserHandle;
24 import android.os.UserManager;
25 
26 import androidx.fragment.app.Fragment;
27 import androidx.fragment.app.FragmentTransaction;
28 import androidx.lifecycle.ViewModelProviders;
29 
30 import com.android.settingslib.RestrictedLockUtils;
31 import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
32 import com.android.settingslib.RestrictedLockUtilsInternal;
33 import com.android.tv.settings.R;
34 import com.android.tv.settings.connectivity.setup.AddStartState;
35 import com.android.tv.settings.connectivity.setup.AdvancedWifiOptionsFlow;
36 import com.android.tv.settings.connectivity.setup.ConnectFailedState;
37 import com.android.tv.settings.connectivity.setup.ConnectState;
38 import com.android.tv.settings.connectivity.setup.EnterPasswordState;
39 import com.android.tv.settings.connectivity.setup.KnownNetworkState;
40 import com.android.tv.settings.connectivity.setup.OptionsOrConnectState;
41 import com.android.tv.settings.connectivity.setup.SuccessState;
42 import com.android.tv.settings.connectivity.setup.UserChoiceInfo;
43 import com.android.tv.settings.connectivity.util.State;
44 import com.android.tv.settings.connectivity.util.StateMachine;
45 import com.android.tv.settings.core.instrumentation.InstrumentedActivity;
46 import com.android.tv.settings.library.network.AccessPoint;
47 import com.android.tv.settings.library.util.DataBinder;
48 import com.android.wifitrackerlib.WifiEntry;
49 
50 /**
51  * Add a wifi network where we already know the ssid/security; normal post-install settings.
52  */
53 public class WifiConnectionActivity extends InstrumentedActivity implements
54         State.FragmentChangeListener {
55     private static final String TAG = "WifiConnectionActivity";
56 
57     private static final String EXTRA_WIFI_ENTRY = "wifi_entry";
58 
createIntent(Context context, AccessPoint result)59     public static Intent createIntent(Context context, AccessPoint result) {
60         Bundle bundle = new Bundle();
61         bundle.putBinder(EXTRA_WIFI_ENTRY, DataBinder.with(result.getWifiEntry()));
62         return new Intent(context, WifiConnectionActivity.class)
63                 .putExtras(bundle);
64     }
65 
66     private StateMachine mStateMachine;
67     private State mConnectFailureState;
68     private State mConnectState;
69     private State mEnterPasswordState;
70     private State mKnownNetworkState;
71     private State mSuccessState;
72     private State mOptionsOrConnectState;
73     private State mAddStartState;
74     private State mFinishState;
75 
76     private final StateMachine.Callback mStateMachineCallback = new StateMachine.Callback() {
77         @Override
78         public void onFinish(int result) {
79             setResult(result);
80             finish();
81         }
82     };
83 
84     @Override
onCreate(Bundle savedInstanceState)85     protected void onCreate(Bundle savedInstanceState) {
86         super.onCreate(savedInstanceState);
87         NetworkChangeStateManager.getInstance().setIsNetworkStateKnown(false);
88         final UserManager userManager = UserManager.get(this);
89         if (userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI)) {
90             EnforcedAdmin admin = RestrictedLockUtilsInternal.checkIfRestrictionEnforced(this,
91                         UserManager.DISALLOW_CONFIG_WIFI, UserHandle.myUserId());
92             if (admin != null) {
93                 RestrictedLockUtils.sendShowAdminSupportDetailsIntent(this, admin);
94             }
95             finish();
96             return;
97         }
98 
99         setContentView(R.layout.wifi_container);
100         mStateMachine = ViewModelProviders.of(this).get(StateMachine.class);
101         mStateMachine.setCallback(mStateMachineCallback);
102         mKnownNetworkState = new KnownNetworkState(this);
103         mEnterPasswordState = new EnterPasswordState(this);
104         mConnectState = new ConnectState(this);
105         mConnectFailureState = new ConnectFailedState(this);
106         mSuccessState = new SuccessState(this);
107         mOptionsOrConnectState = new OptionsOrConnectState(this);
108         mAddStartState = new AddStartState(this);
109         mFinishState = new FinishState(this);
110 
111         /* KnownNetwork */
112         mStateMachine.addState(
113                 mKnownNetworkState,
114                 StateMachine.ADD_START,
115                 mAddStartState);
116         mStateMachine.addState(
117                 mKnownNetworkState,
118                 StateMachine.SELECT_WIFI,
119                 mFinishState);
120 
121         /* Add Start */
122         mStateMachine.addState(
123                 mAddStartState,
124                 StateMachine.PASSWORD,
125                 mEnterPasswordState);
126         mStateMachine.addState(
127                 mAddStartState,
128                 StateMachine.CONNECT,
129                 mConnectState);
130 
131         /* Enter Password */
132         mStateMachine.addState(
133                 mEnterPasswordState,
134                 StateMachine.OPTIONS_OR_CONNECT,
135                 mOptionsOrConnectState);
136 
137         /* Option or Connect */
138         mStateMachine.addState(
139                 mOptionsOrConnectState,
140                 StateMachine.CONNECT,
141                 mConnectState);
142         mStateMachine.addState(
143                 mOptionsOrConnectState,
144                 StateMachine.RESTART,
145                 mEnterPasswordState);
146 
147         /* Connect */
148         mStateMachine.addState(
149                 mConnectState,
150                 StateMachine.RESULT_FAILURE,
151                 mConnectFailureState);
152         mStateMachine.addState(
153                 mConnectState,
154                 StateMachine.RESULT_SUCCESS,
155                 mSuccessState);
156 
157         /* Connect Failed */
158         mStateMachine.addState(
159                 mConnectFailureState,
160                 StateMachine.TRY_AGAIN,
161                 mOptionsOrConnectState
162         );
163         mStateMachine.addState(
164                 mConnectFailureState,
165                 StateMachine.SELECT_WIFI,
166                 mFinishState
167         );
168 
169         WifiEntry wifiEntry = DataBinder.getData(
170                 getIntent().getExtras().getBinder(EXTRA_WIFI_ENTRY));
171 
172         AdvancedWifiOptionsFlow.createFlow(
173                 this, false, true, null,
174                 mOptionsOrConnectState, mConnectState, AdvancedWifiOptionsFlow.START_DEFAULT_PAGE);
175         UserChoiceInfo userChoiceInfo =
176                     ViewModelProviders.of(this).get(UserChoiceInfo.class);
177         userChoiceInfo.setWifiEntry(wifiEntry);
178         userChoiceInfo.setWifiConfiguration(
179                 wifiEntry.isSaved()
180                 ? wifiEntry.getWifiConfiguration()
181                 : WifiConfigHelper.getConfiguration(wifiEntry.getSsid(),
182                         AccessPoint.getSecurity(wifiEntry)));
183         userChoiceInfo.setWifiSecurity(AccessPoint.getSecurity(wifiEntry));
184 
185         if (wifiEntry.shouldEditBeforeConnect()) {
186             mStateMachine.setStartState(mEnterPasswordState);
187         } else if (wifiEntry.isSaved()) {
188             mStateMachine.setStartState(mKnownNetworkState);
189         } else {
190             mStateMachine.setStartState(mAddStartState);
191         }
192         mStateMachine.start(true);
193     }
194 
195     @Override
onBackPressed()196     public void onBackPressed() {
197         mStateMachine.back();
198     }
199 
updateView(androidx.fragment.app.Fragment fragment, boolean movingForward)200     private void updateView(androidx.fragment.app.Fragment fragment, boolean movingForward) {
201         if (fragment != null) {
202             FragmentTransaction updateTransaction = getSupportFragmentManager().beginTransaction();
203             if (movingForward) {
204                 updateTransaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
205             } else {
206                 updateTransaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_CLOSE);
207             }
208             updateTransaction.replace(R.id.wifi_container, fragment, TAG);
209             updateTransaction.commitAllowingStateLoss();
210         }
211     }
212 
213     @Override
onFragmentChange(Fragment newFragment, boolean movingForward)214     public void onFragmentChange(Fragment newFragment, boolean movingForward) {
215         updateView(newFragment, movingForward);
216     }
217 
218 }
219