/**
|
* Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
*
|
* You may not use this file except in compliance with the License. A copy of the License is located the "LICENSE.txt"
|
* file accompanying this source. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the specific language governing permissions and limitations
|
* under the License.
|
*/
|
package com.rockchip.smart.rockhome.softap.http;
|
|
import android.content.Context;
|
import android.os.Build;
|
import android.text.TextUtils;
|
import android.util.Log;
|
|
import com.rockchip.smart.rockhome.R;
|
import com.rockchip.smart.rockhome.WifiInfo;
|
|
import org.apache.commons.io.IOUtils;
|
import org.json.JSONArray;
|
import org.json.JSONException;
|
import org.json.JSONObject;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.DataOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.net.HttpURLConnection;
|
import java.net.InetAddress;
|
import java.net.Socket;
|
import java.net.URL;
|
import java.net.UnknownHostException;
|
import java.security.KeyManagementException;
|
import java.security.KeyStore;
|
import java.security.NoSuchAlgorithmException;
|
import java.security.cert.Certificate;
|
import java.security.cert.CertificateFactory;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import javax.net.ssl.HttpsURLConnection;
|
import javax.net.ssl.SSLContext;
|
import javax.net.ssl.SSLSocket;
|
import javax.net.ssl.SSLSocketFactory;
|
import javax.net.ssl.TrustManagerFactory;
|
|
public class ProvisioningClient {
|
private static final String TAG = "ProvisioningClient";
|
private String endpoint;
|
private SSLSocketFactory pinnedSSLSocketFactory;
|
|
private static ProvisioningClient mClient;
|
|
public static ProvisioningClient getProvisioningClient(Context context) {
|
if (mClient == null) {
|
try {
|
mClient = new ProvisioningClient(context);
|
mClient.setEndpoint("http://10.201.126.1:8443");
|
} catch (Exception e) {
|
|
}
|
}
|
return mClient;
|
}
|
|
private ProvisioningClient(Context context) throws Exception {
|
this.pinnedSSLSocketFactory = getPinnedSSLSocketFactory(context);
|
}
|
|
public void setEndpoint(String endpoint) {
|
this.endpoint = endpoint;
|
}
|
|
public boolean isWifiConnected() {
|
Log.d(TAG, "check isWifiConnected");
|
try {
|
DeviceContextInfo info = getDeviceContextInfo();
|
return !info.getIp().equals("127.0.0.1");
|
} catch (JSONException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return false;
|
}
|
|
public DeviceContextInfo getDeviceContextInfo() throws JSONException, IOException {
|
URL companionInfoEndpoint = new URL(endpoint + "/provision/deviceContext");
|
|
HttpURLConnection connection = (HttpURLConnection) companionInfoEndpoint.openConnection();
|
|
JSONObject request = doRequest(connection);
|
|
String ssid = request.getString("ssid");
|
String ip = request.getString("ip");
|
boolean authorized = request.getBoolean("authorized");
|
|
return new DeviceContextInfo(ssid, ip, authorized);
|
}
|
|
public List<WifiInfo> getWifiListInfo() throws JSONException, IOException {
|
List<WifiInfo> result = new ArrayList<WifiInfo>();
|
URL companionInfoEndpoint = new URL(endpoint + "/provision/wifiListInfo");
|
HttpURLConnection connection = (HttpURLConnection) companionInfoEndpoint.openConnection();
|
|
JSONObject response = doRequest(connection);
|
if (response == null) {
|
Log.d(TAG, "Get wifi list, response is null.");
|
return result;
|
}
|
|
JSONArray array = response.getJSONArray("content");
|
if (array == null) {
|
return result;
|
}
|
|
JSONObject obj = null;
|
WifiInfo info = null;
|
int length = array.length();
|
|
for (int i=0; i<length; i++) {
|
obj = array.getJSONObject(i);
|
info = new WifiInfo();
|
|
info.setBssid(obj.getString(WifiInfo.BSSID));
|
info.setFlags(obj.getString(WifiInfo.FLAGS));
|
info.setFrequency(obj.getString(WifiInfo.FREQUENCY));
|
info.setSignalLevel(obj.getString(WifiInfo.SIGNALLEVEL));
|
info.setSsid(obj.getString(WifiInfo.SSID));
|
result.add(info);
|
}
|
return result;
|
}
|
|
public boolean postWifiSetupInfo(String ssid, String pwd) {
|
try {
|
JSONObject jsonObject = new JSONObject();
|
jsonObject.put("ssid", ssid);
|
jsonObject.put("pwd", pwd);
|
|
Log.d(TAG, jsonObject.toString());
|
URL companionInfoEndpoint = new URL(endpoint + "/provision/wifiSetup");
|
HttpURLConnection connection = (HttpURLConnection) companionInfoEndpoint.openConnection();
|
return doRequestForResult(connection, jsonObject.toString());
|
} catch (JSONException | IOException e ) {
|
e.printStackTrace();
|
Log.d(TAG, Log.getStackTraceString(e));
|
}
|
return false;
|
}
|
|
public boolean postConnectResult(boolean result) {
|
try {
|
JSONObject jsonObject = new JSONObject();
|
jsonObject.put("result", result ? "1" : "0");
|
|
Log.d(TAG, jsonObject.toString());
|
URL companionInfoEndpoint = new URL(endpoint + "/provision/connectResult");
|
HttpURLConnection connection = (HttpURLConnection) companionInfoEndpoint.openConnection();
|
return doRequestForResult(connection, jsonObject.toString());
|
} catch (JSONException | IOException e ) {
|
e.printStackTrace();
|
Log.d(TAG, Log.getStackTraceString(e));
|
}
|
return false;
|
}
|
|
public boolean checkWifiState() {
|
try {
|
URL companionInfoEndpoint = new URL(endpoint + "/provision/wifiState");
|
HttpURLConnection connection = (HttpURLConnection) companionInfoEndpoint.openConnection();
|
String response = doRequestGetString(connection);
|
Log.d("WifiFragment", "checkWifiState " + response);
|
|
if (response.equals("1")) {
|
return true;
|
}
|
} catch (JSONException | IOException e) {
|
e.printStackTrace();
|
}
|
return false;
|
}
|
|
JSONObject doRequest(HttpURLConnection connection) throws IOException, JSONException {
|
return doRequest(connection, null);
|
}
|
|
JSONObject doRequest(HttpURLConnection connection, String data) throws IOException, JSONException {
|
int responseCode = -1;
|
InputStream response = null;
|
DataOutputStream outputStream = null;
|
|
try {
|
if (connection instanceof HttpsURLConnection) {
|
((HttpsURLConnection) connection).setSSLSocketFactory(pinnedSSLSocketFactory);
|
}
|
|
connection.setRequestProperty("Content-Type", "application/json");
|
if (data != null) {
|
connection.setRequestMethod("POST");
|
connection.setDoOutput(true);
|
|
outputStream = new DataOutputStream(connection.getOutputStream());
|
outputStream.write(data.getBytes());
|
outputStream.flush();
|
outputStream.close();
|
} else {
|
connection.setRequestMethod("GET");
|
}
|
|
responseCode = connection.getResponseCode();
|
Log.d(TAG, "responseCode:" + responseCode);
|
response = connection.getInputStream();
|
|
if (responseCode != 204) {
|
String responseString = IOUtils.toString(response);
|
if (TextUtils.isEmpty(responseString))
|
return null;
|
JSONObject jsonObject = new JSONObject(responseString);
|
return jsonObject;
|
} else {
|
return null;
|
}
|
} catch (IOException e) {
|
if (responseCode < 200 || responseCode >= 300) {
|
response = connection.getErrorStream();
|
if (response != null) {
|
String responseString = IOUtils.toString(response);
|
//throw new RuntimeException(responseString);
|
}
|
}
|
throw e;
|
} finally {
|
IOUtils.closeQuietly(outputStream);
|
IOUtils.closeQuietly(response);
|
}
|
}
|
|
String doRequestGetString(HttpURLConnection connection) throws IOException, JSONException {
|
int responseCode = -1;
|
InputStream response = null;
|
DataOutputStream outputStream = null;
|
|
try {
|
if (connection instanceof HttpsURLConnection) {
|
((HttpsURLConnection) connection).setSSLSocketFactory(pinnedSSLSocketFactory);
|
}
|
|
connection.setRequestProperty("Content-Type", "application/json");
|
connection.setRequestMethod("GET");
|
|
responseCode = connection.getResponseCode();
|
Log.d(TAG, "responseCode:" + responseCode);
|
response = connection.getInputStream();
|
|
if (responseCode != 204) {
|
String responseString = IOUtils.toString(response);
|
if (TextUtils.isEmpty(responseString))
|
return "";
|
|
return responseString;
|
} else {
|
return "";
|
}
|
} catch (IOException e) {
|
if (responseCode < 200 || responseCode >= 300) {
|
response = connection.getErrorStream();
|
if (response != null) {
|
String responseString = IOUtils.toString(response);
|
//throw new RuntimeException(responseString);
|
}
|
}
|
throw e;
|
} finally {
|
IOUtils.closeQuietly(outputStream);
|
IOUtils.closeQuietly(response);
|
}
|
}
|
|
boolean doRequestForResult(HttpURLConnection connection, String data) throws IOException, JSONException {
|
int responseCode = -1;
|
InputStream response = null;
|
DataOutputStream outputStream = null;
|
|
try {
|
if (connection instanceof HttpsURLConnection) {
|
((HttpsURLConnection) connection).setSSLSocketFactory(pinnedSSLSocketFactory);
|
}
|
|
connection.setRequestProperty("Content-Type", "application/json");
|
if (data != null) {
|
connection.setRequestMethod("POST");
|
connection.setDoOutput(true);
|
|
outputStream = new DataOutputStream(connection.getOutputStream());
|
outputStream.write(data.getBytes());
|
outputStream.flush();
|
outputStream.close();
|
} else {
|
connection.setRequestMethod("GET");
|
}
|
|
responseCode = connection.getResponseCode();
|
Log.d(TAG, "responseCode:" + responseCode);
|
response = connection.getInputStream();
|
|
if (responseCode == 200) {
|
return true;
|
}
|
} catch (IOException e) {
|
|
} finally {
|
IOUtils.closeQuietly(outputStream);
|
IOUtils.closeQuietly(response);
|
}
|
return false;
|
}
|
|
private SSLSocketFactory getPinnedSSLSocketFactory(Context context) throws Exception {
|
InputStream caCertInputStream = null;
|
try {
|
caCertInputStream = context.getResources().openRawResource(R.raw.ca);
|
CertificateFactory cf = CertificateFactory.getInstance("X.509");
|
Certificate caCert = cf.generateCertificate(caCertInputStream);
|
|
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
|
trustStore.load(null, null);
|
trustStore.setCertificateEntry("myca", caCert);
|
|
TrustManagerFactory trustManagerFactory =
|
TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
|
trustManagerFactory.init(trustStore);
|
|
SSLContext sslContext = SSLContext.getInstance("TLS");
|
sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
|
|
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
|
return new TLSSocketFactory(sslContext.getSocketFactory());
|
}
|
|
return sslContext.getSocketFactory();
|
} finally {
|
IOUtils.closeQuietly(caCertInputStream);
|
}
|
}
|
|
private SSLSocketFactory getPinnedSSLSocketFactory(String crt) throws Exception {
|
InputStream caCertInputStream = null;
|
try {
|
caCertInputStream = new ByteArrayInputStream(crt.getBytes("UTF-8"));
|
CertificateFactory cf = CertificateFactory.getInstance("X.509");
|
Certificate caCert = cf.generateCertificate(caCertInputStream);
|
|
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
|
trustStore.load(null, null);
|
trustStore.setCertificateEntry("myca", caCert);
|
|
TrustManagerFactory trustManagerFactory =
|
TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
|
trustManagerFactory.init(trustStore);
|
|
SSLContext sslContext = SSLContext.getInstance("TLS");
|
sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
|
return sslContext.getSocketFactory();
|
} finally {
|
IOUtils.closeQuietly(caCertInputStream);
|
}
|
}
|
|
public static class TLSSocketFactory extends SSLSocketFactory {
|
|
private SSLSocketFactory internalSSLSocketFactory;
|
|
public TLSSocketFactory(SSLSocketFactory delegate) throws KeyManagementException, NoSuchAlgorithmException {
|
internalSSLSocketFactory = delegate;
|
}
|
|
@Override
|
public String[] getDefaultCipherSuites() {
|
return internalSSLSocketFactory.getDefaultCipherSuites();
|
}
|
|
@Override
|
public String[] getSupportedCipherSuites() {
|
return internalSSLSocketFactory.getSupportedCipherSuites();
|
}
|
|
@Override
|
public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
|
return enableTLSOnSocket(internalSSLSocketFactory.createSocket(s, host, port, autoClose));
|
}
|
|
@Override
|
public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
|
return enableTLSOnSocket(internalSSLSocketFactory.createSocket(host, port));
|
}
|
|
@Override
|
public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
|
return enableTLSOnSocket(internalSSLSocketFactory.createSocket(host, port, localHost, localPort));
|
}
|
|
@Override
|
public Socket createSocket(InetAddress host, int port) throws IOException {
|
return enableTLSOnSocket(internalSSLSocketFactory.createSocket(host, port));
|
}
|
|
@Override
|
public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
|
return enableTLSOnSocket(internalSSLSocketFactory.createSocket(address, port, localAddress, localPort));
|
}
|
|
/*
|
* Utility methods
|
*/
|
private static Socket enableTLSOnSocket(Socket socket) {
|
if (socket != null && (socket instanceof SSLSocket)
|
&& isTLSServerEnabled((SSLSocket) socket)) { // skip the fix if server doesn't provide the TLS version
|
((SSLSocket) socket).setEnabledProtocols(new String[]{"TLSv1.2"});
|
}
|
return socket;
|
}
|
|
private static boolean isTLSServerEnabled(SSLSocket sslSocket) {
|
for (String protocol : sslSocket.getSupportedProtocols()) {
|
if (protocol.equals("TLSv1.2")) {
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
}
|
