diff --git a/app/src/androidTest/java/com/metova/wisefy/WiseFyTest.java b/app/src/androidTest/java/com/metova/wisefy/WiseFyTest.java
index 59eb8470..92c216fb 100644
--- a/app/src/androidTest/java/com/metova/wisefy/WiseFyTest.java
+++ b/app/src/androidTest/java/com/metova/wisefy/WiseFyTest.java
@@ -34,6 +34,8 @@ public class WiseFyTest extends BaseTestClass<TestActivity> {
 
     private WifiManager mMockWiFiManager;
 
+    private WiseFy mWiseFy = new WiseFy.getSmarts().initiateHamsters();
+
     public WiseFyTest() {
         super(TestActivity.class);
     }
@@ -47,134 +49,146 @@ public void setUp() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(mMockWiFiManager);
         when(mMockGetManagerUtil.getConnectivityManager(any(Activity.class))).thenReturn(mMockConnectivityManager);
 
-        WiseFy.getSmarts().mGetManagerUtil = mMockGetManagerUtil;
+        mWiseFy.mGetManagerUtil = mMockGetManagerUtil;
 
         mActivityTestRule.launchActivity(new Intent());
     }
 
     @Test
     public void testAddOpenNetwork() {
-        int result = WiseFy.getSmarts().addOpenNetwork(mActivityTestRule.getActivity(), OPEN_NETWORK_SSID);
+        int result = mWiseFy.addOpenNetwork(mActivityTestRule.getActivity(), OPEN_NETWORK_SSID);
         assertNotEquals(WiseFy.WIFI_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddOpenNetworkFailureToAdd() {
         when(mMockWiFiManager.addNetwork(any(WifiConfiguration.class))).thenReturn(WiseFy.WIFI_MANAGER_FAILURE);
-        int result = WiseFy.getSmarts().addOpenNetwork(mActivityTestRule.getActivity(), OPEN_NETWORK_SSID);
+        int result = mWiseFy.addOpenNetwork(mActivityTestRule.getActivity(), OPEN_NETWORK_SSID);
         assertEquals(WiseFy.WIFI_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddOpenNetworkNullActivity() {
-        int result = WiseFy.getSmarts().addOpenNetwork(null, OPEN_NETWORK_SSID);
+        int result = mWiseFy.addOpenNetwork(null, OPEN_NETWORK_SSID);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddOpenNetworkNullPassword() {
-        int result = WiseFy.getSmarts().addOpenNetwork(mActivityTestRule.getActivity(), null);
+        int result = mWiseFy.addOpenNetwork(mActivityTestRule.getActivity(), null);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddOpenNetworkNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        int result = WiseFy.getSmarts().addOpenNetwork(mActivityTestRule.getActivity(), OPEN_NETWORK_SSID);
+        int result = mWiseFy.addOpenNetwork(mActivityTestRule.getActivity(), OPEN_NETWORK_SSID);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWEPNetwork() {
-        int result = WiseFy.getSmarts().addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
+        int result = mWiseFy.addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
         assertNotEquals(WiseFy.WIFI_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWEPNetworkFailureToAdd() {
         when(mMockWiFiManager.addNetwork(any(WifiConfiguration.class))).thenReturn(WiseFy.WIFI_MANAGER_FAILURE);
-        int result = WiseFy.getSmarts().addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
+        int result = mWiseFy.addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
         assertEquals(WiseFy.WIFI_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWEPNetworkNullActivity() {
-        int result = WiseFy.getSmarts().addWEPNetwork(null, WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
+        int result = mWiseFy.addWEPNetwork(null, WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWEPNetworkNullSSID() {
-        int result = WiseFy.getSmarts().addWEPNetwork(mActivityTestRule.getActivity(), null, WEP_NETWORK_PASSWORD);
+        int result = mWiseFy.addWEPNetwork(mActivityTestRule.getActivity(), null, WEP_NETWORK_PASSWORD);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWEPNetworkNullPassword() {
-        int result = WiseFy.getSmarts().addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, null);
+        int result = mWiseFy.addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, null);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWEPNetworkNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        int result = WiseFy.getSmarts().addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
+        int result = mWiseFy.addWEPNetwork(mActivityTestRule.getActivity(), WEP_NETWORK_SSID, WEP_NETWORK_PASSWORD);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWPA2Network() {
-        int result = WiseFy.getSmarts().addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
+        int result = mWiseFy.addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
         assertNotEquals(WiseFy.WIFI_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWPA2NetworkFailureToAdd() {
         when(mMockWiFiManager.addNetwork(any(WifiConfiguration.class))).thenReturn(WiseFy.WIFI_MANAGER_FAILURE);
-        int result = WiseFy.getSmarts().addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
+        int result = mWiseFy.addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
         assertEquals(WiseFy.WIFI_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWPA2NetworkNullActivity() {
-        int result = WiseFy.getSmarts().addWPA2Network(null, WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
+        int result = mWiseFy.addWPA2Network(null, WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWPA2NetworkNullSSID() {
-        int result = WiseFy.getSmarts().addWPA2Network(mActivityTestRule.getActivity(), null, WPA2_NETWORK_PASSWORD);
+        int result = mWiseFy.addWPA2Network(mActivityTestRule.getActivity(), null, WPA2_NETWORK_PASSWORD);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWPA2NetworkNullPassword() {
-        int result = WiseFy.getSmarts().addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, null);
+        int result = mWiseFy.addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, null);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
     @Test
     public void testAddWPA2NetworkNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        int result = WiseFy.getSmarts().addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
+        int result = mWiseFy.addWPA2Network(mActivityTestRule.getActivity(), WPA2_NETWORK_SSID, WPA2_NETWORK_PASSWORD);
         assertEquals(WiseFy.WISE_MANAGER_FAILURE, result);
     }
 
+    @Test
+    public void testBuilderWithLoggingFalse() {
+        WiseFy wiseFy = new WiseFy.getSmarts().withLogging(false).initiateHamsters();
+        assertEquals(false, wiseFy.isLoggingEnabled());
+    }
+
+    @Test
+    public void testBuilderWithLoggingTrue() {
+        WiseFy wiseFy = new WiseFy.getSmarts().withLogging(true).initiateHamsters();
+        assertEquals(true, wiseFy.isLoggingEnabled());
+    }
+
     @Test
     public void testCalculateBar() {
-        int result = WiseFy.getSmarts().calculateBars(-35, 5);
+        int result = mWiseFy.calculateBars(-35, 5);
         assertEquals(4, result);
     }
 
     @Test
     public void testCompareSignalLevel() {
-        int result = WiseFy.getSmarts().compareSignalLevel(-35, -70);
+        int result = mWiseFy.compareSignalLevel(-35, -70);
         assertEquals(35, result);
     }
 
     @Test
     public void testConnectToNetworkFailureNoList() {
-        boolean result = WiseFy.getSmarts().connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
+        boolean result = mWiseFy.connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
         assertEquals(false, result);
     }
 
@@ -197,7 +211,7 @@ public void testConnectToNetworkFailureNotAvailable() {
         when(mockNetworkInfo.isAvailable()).thenReturn(false);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
+        boolean result = mWiseFy.connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
         assertEquals(false, result);
     }
 
@@ -220,20 +234,20 @@ public void testConnectToNetworkFailureNotConnected() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
+        boolean result = mWiseFy.connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
         assertEquals(false, result);
     }
 
     @Test
     public void testConnectToNetworkFailureNullActivity() {
-        boolean result = WiseFy.getSmarts().connectToNetwork(null, TEST_SSID, 1);
+        boolean result = mWiseFy.connectToNetwork(null, TEST_SSID, 1);
         assertEquals(false, result);
     }
 
     @Test
     public void testConnectToNetworkFailureNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        boolean result = WiseFy.getSmarts().connectToNetwork(null, TEST_SSID, 1);
+        boolean result = mWiseFy.connectToNetwork(null, TEST_SSID, 1);
         assertEquals(false, result);
     }
 
@@ -256,28 +270,28 @@ public void testConnectToNetworkSuccess() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
+        boolean result = mWiseFy.connectToNetwork(mActivityTestRule.getActivity(), TEST_SSID, 1);
         assertEquals(true, result);
     }
 
     @Test
     public void testDisableWifiFailure() {
         when(mMockWiFiManager.setWifiEnabled(anyBoolean())).thenReturn(true);
-        boolean result = WiseFy.getSmarts().disableWifi(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.disableWifi(mActivityTestRule.getActivity());
         verify(mMockWiFiManager).setWifiEnabled(false);
         assertEquals(true, result);
     }
 
     @Test
     public void testDisableWifiNullActivity() {
-        boolean result = WiseFy.getSmarts().disableWifi(null);
+        boolean result = mWiseFy.disableWifi(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testDisableWifiSuccess() {
         when(mMockWiFiManager.setWifiEnabled(anyBoolean())).thenReturn(true);
-        boolean result = WiseFy.getSmarts().disableWifi(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.disableWifi(mActivityTestRule.getActivity());
         verify(mMockWiFiManager).setWifiEnabled(false);
         assertEquals(true, result);
     }
@@ -285,21 +299,21 @@ public void testDisableWifiSuccess() {
     @Test
     public void testDisconnectFromCurrentNetworkFailure() {
         when(mMockWiFiManager.disconnect()).thenReturn(false);
-        boolean result = WiseFy.getSmarts().disconnectFromCurrentNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.disconnectFromCurrentNetwork(mActivityTestRule.getActivity());
         verify(mMockWiFiManager).disconnect();
         assertEquals(false, result);
     }
 
     @Test
     public void testDisconnectFromCurrentNetworkNullActivity() {
-        boolean result = WiseFy.getSmarts().disconnectFromCurrentNetwork(null);
+        boolean result = mWiseFy.disconnectFromCurrentNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testDisconnectFromCurrentNetworkSuccess() {
         when(mMockWiFiManager.disconnect()).thenReturn(true);
-        boolean result = WiseFy.getSmarts().disconnectFromCurrentNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.disconnectFromCurrentNetwork(mActivityTestRule.getActivity());
         verify(mMockWiFiManager).disconnect();
         assertEquals(true, result);
     }
@@ -307,21 +321,21 @@ public void testDisconnectFromCurrentNetworkSuccess() {
     @Test
     public void testEnableWiFiFailure() {
         when(mMockWiFiManager.setWifiEnabled(anyBoolean())).thenReturn(false);
-        boolean result = WiseFy.getSmarts().enableWifi(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.enableWifi(mActivityTestRule.getActivity());
         verify(mMockWiFiManager).setWifiEnabled(true);
         assertEquals(false, result);
     }
 
     @Test
     public void testEnableWiFiNullActivity() {
-        boolean result = WiseFy.getSmarts().enableWifi(null);
+        boolean result = mWiseFy.enableWifi(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testEnableWiFiSuccess() {
         when(mMockWiFiManager.setWifiEnabled(anyBoolean())).thenReturn(true);
-        boolean result = WiseFy.getSmarts().enableWifi(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.enableWifi(mActivityTestRule.getActivity());
         verify(mMockWiFiManager).setWifiEnabled(true);
         assertEquals(true, result);
     }
@@ -332,18 +346,18 @@ public void testGetCurrentNetwork() {
         when(mockWifiInfo.getSSID()).thenReturn(TEST_SSID);
         when(mMockWiFiManager.getConnectionInfo()).thenReturn(mockWifiInfo);
 
-        assertEquals(TEST_SSID, WiseFy.getSmarts().getCurrentNetwork(mActivityTestRule.getActivity()).getSSID());
+        assertEquals(TEST_SSID, mWiseFy.getCurrentNetwork(mActivityTestRule.getActivity()).getSSID());
     }
 
     @Test
     public void testGetCurrentNetworkNullActivity() {
-        assertEquals(null, WiseFy.getSmarts().getCurrentNetwork(null));
+        assertEquals(null, mWiseFy.getCurrentNetwork(null));
     }
 
     @Test
     public void testGetCurrentNetworkNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        assertEquals(null, WiseFy.getSmarts().getCurrentNetwork(mActivityTestRule.getActivity()));
+        assertEquals(null, mWiseFy.getCurrentNetwork(mActivityTestRule.getActivity()));
     }
 
     @Test
@@ -358,7 +372,7 @@ public void testGetNearbyAccessPoints() {
 
         when(mMockWiFiManager.getScanResults()).thenReturn(scanResults);
 
-        List<ScanResult> results = WiseFy.getSmarts().getNearbyAccessPoints(mActivityTestRule.getActivity(), false);
+        List<ScanResult> results = mWiseFy.getNearbyAccessPoints(mActivityTestRule.getActivity(), false);
 
         assertEquals(scanResults, results);
         assertEquals(2, results.size());
@@ -376,7 +390,7 @@ public void testGetNearbyAccessPointsFilterDuplicatesDifferent() {
 
         when(mMockWiFiManager.getScanResults()).thenReturn(scanResults);
 
-        List<ScanResult> results = WiseFy.getSmarts().getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
+        List<ScanResult> results = mWiseFy.getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
 
         assertEquals(scanResults, results);
         assertEquals(2, results.size());
@@ -399,7 +413,7 @@ public void testGetNearbyAccessPointsFilterDuplicatesHigher() {
 
         when(mMockWiFiManager.getScanResults()).thenReturn(scanResults);
 
-        List<ScanResult> results = WiseFy.getSmarts().getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
+        List<ScanResult> results = mWiseFy.getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
 
         assertEquals(expectedScanResults, results);
         assertEquals(1, results.size());
@@ -422,7 +436,7 @@ public void testGetNearbyAccessPointsFilterDuplicatesLower() {
 
         when(mMockWiFiManager.getScanResults()).thenReturn(scanResults);
 
-        List<ScanResult> results = WiseFy.getSmarts().getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
+        List<ScanResult> results = mWiseFy.getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
 
         assertEquals(expectedScanResults, results);
         assertEquals(1, results.size());
@@ -430,14 +444,14 @@ public void testGetNearbyAccessPointsFilterDuplicatesLower() {
 
     @Test
     public void testGetNearbyAccessPointsNullActivity() {
-        List<ScanResult> results = WiseFy.getSmarts().getNearbyAccessPoints(null, true);
+        List<ScanResult> results = mWiseFy.getNearbyAccessPoints(null, true);
         assertEquals(null, results);
     }
 
     @Test
     public void testGetNearbyAccessPointsNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        List<ScanResult> results = WiseFy.getSmarts().getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
+        List<ScanResult> results = mWiseFy.getNearbyAccessPoints(mActivityTestRule.getActivity(), true);
         assertEquals(null, results);
     }
 
@@ -449,18 +463,18 @@ public void testGetSavedNetworks() {
         wifiList.add(mWiFiConfiguration);
         when(mMockWiFiManager.getConfiguredNetworks()).thenReturn(wifiList);
 
-        assertEquals(wifiList, WiseFy.getSmarts().getSavedNetworks(mActivityTestRule.getActivity()));
+        assertEquals(wifiList, mWiseFy.getSavedNetworks(mActivityTestRule.getActivity()));
     }
 
     @Test
     public void testGetSavedNetworksNullActivity() {
-        assertEquals(null, WiseFy.getSmarts().getSavedNetworks(null));
+        assertEquals(null, mWiseFy.getSavedNetworks(null));
     }
 
     @Test
     public void testGetSavedNetworksNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        assertEquals(null, WiseFy.getSmarts().getSavedNetworks(mActivityTestRule.getActivity()));
+        assertEquals(null, mWiseFy.getSavedNetworks(mActivityTestRule.getActivity()));
     }
 
     @Test
@@ -472,7 +486,7 @@ public void testIsDeviceConnectedToMobileNetworkFailureSuccess() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
         assertEquals(true, result);
     }
 
@@ -485,7 +499,7 @@ public void testIsDeviceConnectedToMobileNetworkFailureNotAvailable() {
         when(mockNetworkInfo.isAvailable()).thenReturn(false);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -498,7 +512,7 @@ public void testIsDeviceConnectedToMobileNetworkFailureNotConnected() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -511,20 +525,20 @@ public void testIsDeviceConnectedToMobileNetworkFailureWrongType() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileNetwork(null);
+        boolean result = mWiseFy.isDeviceConnectedToMobileNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToMobileNetworkNullActivity() {
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileNetwork(null);
+        boolean result = mWiseFy.isDeviceConnectedToMobileNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToMobileNetworkNullConfigurationManager() {
         when(mMockGetManagerUtil.getConnectivityManager(any(Activity.class))).thenReturn(null);
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -537,7 +551,7 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureSuccessMobile() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(true, result);
     }
 
@@ -550,7 +564,7 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureSuccessWifi() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(true, result);
     }
 
@@ -563,7 +577,7 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureNotAvailableMobile(
         when(mockNetworkInfo.isAvailable()).thenReturn(false);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -576,7 +590,7 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureNotAvailableWifi()
         when(mockNetworkInfo.isAvailable()).thenReturn(false);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -589,7 +603,7 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureNotConnectedMobile(
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -602,7 +616,7 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureNotConnectedWifi()
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -615,20 +629,20 @@ public void testIsDeviceConnectedToMobileOrWifiNetworkFailureWrongType() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(null);
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToMobileWifiNetworkNullActivity() {
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(null);
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToMobileOrWifiNetworkNullConfigurationManager() {
         when(mMockGetManagerUtil.getConnectivityManager(any(Activity.class))).thenReturn(null);
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToMobileOrWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -651,7 +665,7 @@ public void testIsDeviceConnectedToSSID() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(true, result);
     }
 
@@ -674,7 +688,7 @@ public void testIsDeviceConnectedToSSIDFailureOtherSSID() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(false, result);
     }
 
@@ -697,7 +711,7 @@ public void testIsDeviceConnectedToSSIDFailureNotAvailable() {
         when(mockNetworkInfo.isAvailable()).thenReturn(false);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(false, result);
     }
 
@@ -720,20 +734,20 @@ public void testIsDeviceConnectedToSSIDFailureNotConnected() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToSSIDFailureNullActivity() {
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToSSID(null, TEST_SSID);
+        boolean result = mWiseFy.isDeviceConnectedToSSID(null, TEST_SSID);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToSSIDFailureNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.isDeviceConnectedToSSID(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(false, result);
     }
 
@@ -746,7 +760,7 @@ public void testIsDeviceConnectedToWifiNetworkFailureSuccess() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(true, result);
     }
 
@@ -759,7 +773,7 @@ public void testIsDeviceConnectedToWifiNetworkFailureNotAvailable() {
         when(mockNetworkInfo.isAvailable()).thenReturn(false);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -772,7 +786,7 @@ public void testIsDeviceConnectedToWifiNetworkFailureNotConnected() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
@@ -785,33 +799,33 @@ public void testIsDeviceConnectedToWifiNetworkFailureWrongType() {
         when(mockNetworkInfo.isAvailable()).thenReturn(true);
         when(mockNetworkInfo.isConnected()).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToWifiNetwork(null);
+        boolean result = mWiseFy.isDeviceConnectedToWifiNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToWifiNetworkNullActivity() {
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToWifiNetwork(null);
+        boolean result = mWiseFy.isDeviceConnectedToWifiNetwork(null);
         assertEquals(false, result);
     }
 
     @Test
     public void testIsDeviceConnectedToWifiNetworkNullConfigurationManager() {
         when(mMockGetManagerUtil.getConnectivityManager(any(Activity.class))).thenReturn(null);
-        boolean result = WiseFy.getSmarts().isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
+        boolean result = mWiseFy.isDeviceConnectedToWifiNetwork(mActivityTestRule.getActivity());
         assertEquals(false, result);
     }
 
     @Test
     public void testIsNetworkInConfigurationListFailure() {
-        assertEquals(false, WiseFy.getSmarts().isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
+        assertEquals(false, mWiseFy.isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
     }
 
     @Test
     public void testIsNetworkInConfigurationListFailureNoNetworks() {
         List<WifiConfiguration> wifiList = new ArrayList<>();
         when(mMockWiFiManager.getConfiguredNetworks()).thenReturn(wifiList);
-        assertEquals(false, WiseFy.getSmarts().isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
+        assertEquals(false, mWiseFy.isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
     }
 
     @Test
@@ -821,75 +835,75 @@ public void testIsNetworkInConfigurationListSuccess() {
         mWiFiConfiguration.SSID = TEST_SSID;
         wifiList.add(mWiFiConfiguration);
         when(mMockWiFiManager.getConfiguredNetworks()).thenReturn(wifiList);
-        assertEquals(true, WiseFy.getSmarts().isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
+        assertEquals(true, mWiseFy.isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
     }
 
     @Test
     public void testIsNetworkInConfigurationNullActivity() {
-        assertEquals(false, WiseFy.getSmarts().isNetworkInConfigurationList(null, TEST_SSID));
+        assertEquals(false, mWiseFy.isNetworkInConfigurationList(null, TEST_SSID));
     }
 
     @Test
     public void testIsNetworkInConfigurationNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        assertEquals(false, WiseFy.getSmarts().isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
+        assertEquals(false, mWiseFy.isNetworkInConfigurationList(mActivityTestRule.getActivity(), TEST_SSID));
     }
 
     @Test
     public void testIsNetworkSecureWithWEP() {
         ScanResult scanResult = mock(ScanResult.class);
         scanResult.capabilities = "WEP";
-        assertEquals(true, WiseFy.getSmarts().isNetworkSecure(scanResult));
+        assertEquals(true, mWiseFy.isNetworkSecure(scanResult));
     }
 
     @Test
     public void testIsNetworkSecureWithPSK() {
         ScanResult scanResult = mock(ScanResult.class);
         scanResult.capabilities = "PSK";
-        assertEquals(true, WiseFy.getSmarts().isNetworkSecure(scanResult));
+        assertEquals(true, mWiseFy.isNetworkSecure(scanResult));
     }
 
     @Test
     public void testIsNetworkSecureWithEAP() {
         ScanResult scanResult = mock(ScanResult.class);
         scanResult.capabilities = "EAP";
-        assertEquals(true, WiseFy.getSmarts().isNetworkSecure(scanResult));
+        assertEquals(true, mWiseFy.isNetworkSecure(scanResult));
     }
 
     @Test
     public void testIsNetworkSecureEmptyCapabilities() {
         ScanResult scanResult = mock(ScanResult.class);
         scanResult.capabilities = "";
-        assertEquals(false, WiseFy.getSmarts().isNetworkSecure(scanResult));
+        assertEquals(false, mWiseFy.isNetworkSecure(scanResult));
     }
 
     @Test
     public void testIsNetworkSecureNullCapabilities() {
         ScanResult scanResult = mock(ScanResult.class);
-        assertEquals(false, WiseFy.getSmarts().isNetworkSecure(scanResult));
+        assertEquals(false, mWiseFy.isNetworkSecure(scanResult));
     }
 
     @Test
     public void testIsWifiEnabledFailure() {
         when(mMockWiFiManager.isWifiEnabled()).thenReturn(false);
-        assertEquals(false, WiseFy.getSmarts().isWifiEnabled(mActivityTestRule.getActivity()));
+        assertEquals(false, mWiseFy.isWifiEnabled(mActivityTestRule.getActivity()));
     }
 
     @Test
     public void testIsWifiEnabledSuccess() {
         when(mMockWiFiManager.isWifiEnabled()).thenReturn(true);
-        assertEquals(true, WiseFy.getSmarts().isWifiEnabled(mActivityTestRule.getActivity()));
+        assertEquals(true, mWiseFy.isWifiEnabled(mActivityTestRule.getActivity()));
     }
 
     @Test
     public void testIsWifiEnabledNullActivity() {
-        assertEquals(false, WiseFy.getSmarts().isWifiEnabled(null));
+        assertEquals(false, mWiseFy.isWifiEnabled(null));
     }
 
     @Test
     public void testIsWifiEnabledNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        assertEquals(false, WiseFy.getSmarts().isWifiEnabled(mActivityTestRule.getActivity()));
+        assertEquals(false, mWiseFy.isWifiEnabled(mActivityTestRule.getActivity()));
     }
 
     @Test
@@ -897,7 +911,7 @@ public void testRemoveNetworkFailure() {
         when(mMockWiFiManager.getConfiguredNetworks()).thenReturn(getTestWifiConfiguration());
         when(mMockWiFiManager.removeNetwork(anyInt())).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().removeNetwork(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.removeNetwork(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(false, result);
     }
 
@@ -907,20 +921,20 @@ public void testRemoveNetworkFailureNotInList() {
         when(mMockWiFiManager.getConfiguredNetworks()).thenReturn(wifiList);
         when(mMockWiFiManager.removeNetwork(anyInt())).thenReturn(false);
 
-        boolean result = WiseFy.getSmarts().removeNetwork(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.removeNetwork(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(false, result);
     }
 
     @Test
     public void testRemoveNetworkNullActivity() {
-        boolean result = WiseFy.getSmarts().removeNetwork(null, TEST_SSID);
+        boolean result = mWiseFy.removeNetwork(null, TEST_SSID);
         assertEquals(false, result);
     }
 
     @Test
     public void testRemoveNetworkNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        boolean result = WiseFy.getSmarts().removeNetwork(null, TEST_SSID);
+        boolean result = mWiseFy.removeNetwork(null, TEST_SSID);
         assertEquals(false, result);
     }
 
@@ -933,7 +947,7 @@ public void testRemoveNetworkSuccess() {
         when(mMockWiFiManager.getConfiguredNetworks()).thenReturn(wifiList);
         when(mMockWiFiManager.removeNetwork(anyInt())).thenReturn(true);
 
-        boolean result = WiseFy.getSmarts().removeNetwork(mActivityTestRule.getActivity(), TEST_SSID);
+        boolean result = mWiseFy.removeNetwork(mActivityTestRule.getActivity(), TEST_SSID);
         assertEquals(true, result);
     }
 
@@ -943,18 +957,18 @@ public void testSearchSSIDNFailure() {
         when(mockWifiInfo.getSSID()).thenReturn(TEST_SSID);
         when(mMockWiFiManager.getConnectionInfo()).thenReturn(mockWifiInfo);
 
-        assertEquals(null, WiseFy.getSmarts().searchForSSID(mActivityTestRule.getActivity(), TEST_SSID, 1));
+        assertEquals(null, mWiseFy.searchForSSID(mActivityTestRule.getActivity(), TEST_SSID, 1));
     }
 
     @Test
     public void testSearchSSIDNullActivity() {
-        assertEquals(null, WiseFy.getSmarts().searchForSSID(null, TEST_SSID, 1));
+        assertEquals(null, mWiseFy.searchForSSID(null, TEST_SSID, 1));
     }
 
     @Test
     public void testSearchSSIDNullWifiManager() {
         when(mMockGetManagerUtil.getWiFiManager(any(Activity.class))).thenReturn(null);
-        assertEquals(null, WiseFy.getSmarts().searchForSSID(null, TEST_SSID, 1));
+        assertEquals(null, mWiseFy.searchForSSID(null, TEST_SSID, 1));
     }
 
     @Test
@@ -969,21 +983,6 @@ public void testSearchSSIDSuccess() {
         when(mMockWiFiManager.getConnectionInfo()).thenReturn(mockWifiInfo);
         when(mMockWiFiManager.getScanResults()).thenReturn(scanResults);
 
-        assertEquals(TEST_SSID, WiseFy.getSmarts().searchForSSID(mActivityTestRule.getActivity(), TEST_SSID, 1));
-    }
-
-    @Test
-    public void testSearchSSIDSuccessWithoutLogs() {
-        List<ScanResult> scanResults = new ArrayList<>();
-        ScanResult scanResult = mock(ScanResult.class);
-        scanResult.SSID = TEST_SSID;
-        scanResults.add(scanResult);
-
-        WifiInfo mockWifiInfo = mock(WifiInfo.class);
-        when(mockWifiInfo.getSSID()).thenReturn(TEST_SSID);
-        when(mMockWiFiManager.getConnectionInfo()).thenReturn(mockWifiInfo);
-        when(mMockWiFiManager.getScanResults()).thenReturn(scanResults);
-
-        assertEquals(TEST_SSID, WiseFy.getSmarts(false).searchForSSID(mActivityTestRule.getActivity(), TEST_SSID, 1));
+        assertEquals(TEST_SSID, mWiseFy.searchForSSID(mActivityTestRule.getActivity(), TEST_SSID, 1));
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/metova/wisefy/WiseFy.java b/app/src/main/java/com/metova/wisefy/WiseFy.java
index 43256c76..49a259d4 100644
--- a/app/src/main/java/com/metova/wisefy/WiseFy.java
+++ b/app/src/main/java/com/metova/wisefy/WiseFy.java
@@ -32,27 +32,44 @@ public class WiseFy {
 
     private SSIDUtil mSSIDUtil = SSIDUtil.getInstance();
 
-    private static final WiseFy WISE_FY = new WiseFy();
-
-    private static boolean sLoggingEnabled;
+    private boolean loggingEnabled;
 
     /**
-     * Private constructor with no setup
+     * Private constructor that accepts builder input
      */
-    private WiseFy() {
-
+    private WiseFy(getSmarts getSmarts) {
+        this.loggingEnabled = getSmarts.loggingEnabled;
     }
 
     /**
-     * @return instance of WiseFy
+     * Internal static class for builder pattern
      */
-    public static WiseFy getSmarts() {
-        return WISE_FY;
-    }
+    public static class getSmarts {
+        private boolean loggingEnabled;
+
+        public getSmarts() {
+        }
+
+        /**
+         * To enable/disable logging for the WiseFy instance
+         *
+         * @param loggingEnabled - If logging is enabled or disabled
+         *
+         * @return getSmarts - The builder with updated logging setting
+         */
+        public getSmarts withLogging(boolean loggingEnabled) {
+            this.loggingEnabled = loggingEnabled;
+            return this;
+        }
 
-    public static WiseFy getSmarts(boolean loggingEnabled) {
-        sLoggingEnabled = loggingEnabled;
-        return WISE_FY;
+        /**
+         * To build and return a WiseFy instance
+         *
+         * @return WiseFy - The instance created by the builder
+         */
+        public WiseFy initiateHamsters() {
+            return new WiseFy(this);
+        }
     }
 
     /**
@@ -65,7 +82,7 @@ public static WiseFy getSmarts(boolean loggingEnabled) {
      */
     public int addOpenNetwork(Activity activity, String ssid) {
         if (TextUtils.isEmpty(ssid) || activity == null || activity.isFinishing()) {
-            mLogUtil.w(TAG, "Breaking due to missing ssid or activity. ssid: " + ssid, sLoggingEnabled);
+            mLogUtil.w(TAG, "Breaking due to missing ssid or activity. ssid: " + ssid, loggingEnabled);
             return WISE_MANAGER_FAILURE;
         }
         WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
@@ -73,7 +90,7 @@ public int addOpenNetwork(Activity activity, String ssid) {
             boolean ssidAlreadyConfigured = isNetworkInConfigurationList(wifiManager, ssid);
 
             if (!ssidAlreadyConfigured) {
-                mLogUtil.d(TAG, "Adding open network with SSID " + ssid, sLoggingEnabled);
+                mLogUtil.d(TAG, "Adding open network with SSID " + ssid, loggingEnabled);
 
                 WifiConfiguration wifiConfig = new WifiConfiguration();
 
@@ -106,7 +123,7 @@ public int addOpenNetwork(Activity activity, String ssid) {
      */
     public int addWEPNetwork(Activity activity, String ssid, String password) {
         if (TextUtils.isEmpty(ssid) || TextUtils.isEmpty(password) || activity == null || activity.isFinishing()) {
-            mLogUtil.w(TAG, "Breaking due to missing ssid, password, or activity. ssid: " + ssid + ", password: " + password, sLoggingEnabled);
+            mLogUtil.w(TAG, "Breaking due to missing ssid, password, or activity. ssid: " + ssid + ", password: " + password, loggingEnabled);
             return WISE_MANAGER_FAILURE;
         }
         WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
@@ -114,7 +131,7 @@ public int addWEPNetwork(Activity activity, String ssid, String password) {
             boolean ssidAlreadyConfigured = isNetworkInConfigurationList(wifiManager, ssid);
 
             if (!ssidAlreadyConfigured) {
-                mLogUtil.d(TAG, "Adding WEP network with SSID " + ssid, sLoggingEnabled);
+                mLogUtil.d(TAG, "Adding WEP network with SSID " + ssid, loggingEnabled);
 
                 WifiConfiguration wifiConfig = new WifiConfiguration();
                 wifiConfig.SSID = mSSIDUtil.convertSSIDForConfig(ssid);
@@ -146,7 +163,7 @@ public int addWEPNetwork(Activity activity, String ssid, String password) {
      */
     public int addWPA2Network(Activity activity, String ssid, String password) {
         if (TextUtils.isEmpty(ssid) || TextUtils.isEmpty(password) || activity == null || activity.isFinishing()) {
-            mLogUtil.w(TAG, "Breaking due to missing ssid, password, or activity. ssid: " + ssid + ", password: " + password, sLoggingEnabled);
+            mLogUtil.w(TAG, "Breaking due to missing ssid, password, or activity. ssid: " + ssid + ", password: " + password, loggingEnabled);
             return WISE_MANAGER_FAILURE;
         }
         WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
@@ -154,7 +171,7 @@ public int addWPA2Network(Activity activity, String ssid, String password) {
             boolean ssidAlreadyConfigured = isNetworkInConfigurationList(wifiManager, ssid);
 
             if (!ssidAlreadyConfigured) {
-                mLogUtil.d(TAG, "Adding WPA2 network with SSID " + ssid, sLoggingEnabled);
+                mLogUtil.d(TAG, "Adding WPA2 network with SSID " + ssid, loggingEnabled);
 
                 WifiConfiguration wifiConfig = new WifiConfiguration();
                 wifiConfig.SSID = mSSIDUtil.convertSSIDForConfig(ssid);
@@ -209,14 +226,14 @@ public int compareSignalLevel(int rssi1, int rssi2) {
      * Gets a list of saved networks, connects/reconnects to the given ssid, and then calls waitToConnectToSSID to verify connectivity
      *
      * @param activity - The activity to use as context to retrieve a wifi manager via getSystemService
-     * @param ssidToReconnectTo - The ssid to connect/reconnect to
-     * @param timeout - The approximate number of seconds to keep reconnecting for the SSID
+     * @param ssidToConnectTo - The ssid to connect/reconnect to
+     * @param timeoutInMillis - The number of milliseconds to continue waiting for the device to connect to the given SSID
      *
      * @return boolean - If the network was successfully reconnected
      */
-    public boolean connectToNetwork(Activity activity, String ssidToReconnectTo, int timeout) {
+    public boolean connectToNetwork(Activity activity, String ssidToConnectTo, int timeoutInMillis) {
         if (activity != null && !activity.isFinishing()) {
-            mLogUtil.d(TAG, "Connecting to network: " + ssidToReconnectTo, sLoggingEnabled);
+            mLogUtil.d(TAG, "Connecting to network: " + ssidToConnectTo, loggingEnabled);
             WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
             if (wifiManager != null) {
                 List<WifiConfiguration> list = wifiManager.getConfiguredNetworks();
@@ -226,22 +243,22 @@ public boolean connectToNetwork(Activity activity, String ssidToReconnectTo, int
                         if (wifiConfiguration != null && wifiConfiguration.SSID != null) {
                             String ssidInList = wifiConfiguration.SSID.replaceAll("\"", "");
 
-                            mLogUtil.d(TAG, "Configured WiFi Network {index:" + i + ", ssidInList:" + ssidInList + "}", sLoggingEnabled);
-                            if (ssidInList.equals(ssidToReconnectTo)) {
-                                mLogUtil.d(TAG, "ssidToReconnectTo: " + ssidToReconnectTo + " matches ssidInList:" + ssidInList, sLoggingEnabled);
+                            mLogUtil.d(TAG, "Configured WiFi Network {index:" + i + ", ssidInList:" + ssidInList + "}", loggingEnabled);
+                            if (ssidInList.equals(ssidToConnectTo)) {
+                                mLogUtil.d(TAG, "ssidToReconnectTo: " + ssidToConnectTo + " matches ssidInList:" + ssidInList, loggingEnabled);
                                 wifiManager.disconnect();
                                 wifiManager.enableNetwork(wifiConfiguration.networkId, true);
                                 wifiManager.reconnect();
-                                return waitToConnectToSSID(activity, ssidToReconnectTo, timeout);
+                                return waitToConnectToSSID(activity, ssidToConnectTo, timeoutInMillis);
                             }
                         }
                     }
                 }
 
             }
-            mLogUtil.w(TAG, "ssidToReconnectTo: " + ssidToReconnectTo + " was not found in list to reconnect to", sLoggingEnabled);
+            mLogUtil.w(TAG, "ssidToReconnectTo: " + ssidToConnectTo + " was not found in list to reconnect to", loggingEnabled);
         } else {
-            mLogUtil.w(TAG, "No activity to reconnect to network", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to reconnect to network", loggingEnabled);
         }
         return false;
     }
@@ -260,7 +277,7 @@ public boolean disableWifi(Activity activity) {
                 return wifiManager.setWifiEnabled(false);
             }
         } else {
-            mLogUtil.w(TAG, "No activity to disable Wifi", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to disable Wifi", loggingEnabled);
         }
         return false;
     }
@@ -274,13 +291,13 @@ public boolean disableWifi(Activity activity) {
      */
     public boolean disconnectFromCurrentNetwork(Activity activity) {
         if (activity != null && !activity.isFinishing()) {
-            mLogUtil.d(TAG, "Disconnecting from current network", sLoggingEnabled);
+            mLogUtil.d(TAG, "Disconnecting from current network", loggingEnabled);
             WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
             if (wifiManager != null) {
                 return wifiManager.disconnect();
             }
         } else {
-            mLogUtil.w(TAG, "No activity to disconnect from current network", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to disconnect from current network", loggingEnabled);
         }
         return false;
     }
@@ -294,13 +311,13 @@ public boolean disconnectFromCurrentNetwork(Activity activity) {
      */
     public boolean enableWifi(Activity activity) {
         if (activity != null && !activity.isFinishing()) {
-            mLogUtil.d(TAG, "Enabling WiFi", sLoggingEnabled);
+            mLogUtil.d(TAG, "Enabling WiFi", loggingEnabled);
             WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
             if (wifiManager != null) {
                 return wifiManager.setWifiEnabled(true);
             }
         } else {
-            mLogUtil.w(TAG, "No activity to enable Wifi", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to enable Wifi", loggingEnabled);
         }
         return false;
     }
@@ -319,7 +336,7 @@ public WifiInfo getCurrentNetwork(Activity activity) {
                 return wifiManager.getConnectionInfo();
             }
         } else {
-            mLogUtil.w(TAG, "No activity to get current network", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to get current network", loggingEnabled);
         }
         return null;
     }
@@ -349,26 +366,26 @@ public List<ScanResult> getNearbyAccessPoints(Activity activity, boolean filterD
                         boolean found = false;
                         for (int i = 0; i < scanResultsToReturn.size(); i++) {
                             ScanResult scanResult = scanResultsToReturn.get(i);
-                            mLogUtil.d(TAG, "SSID 1: " + newScanResult.SSID + ". SSID 2: " + scanResult.SSID, sLoggingEnabled);
+                            mLogUtil.d(TAG, "SSID 1: " + newScanResult.SSID + ". SSID 2: " + scanResult.SSID, loggingEnabled);
                             if (newScanResult.SSID.equalsIgnoreCase(scanResult.SSID)) {
                                 found = true;
-                                mLogUtil.d(TAG, "SSID did match", sLoggingEnabled);
+                                mLogUtil.d(TAG, "SSID did match", loggingEnabled);
 
-                                mLogUtil.d(TAG, "Current level: " + scanResult.level, sLoggingEnabled);
-                                mLogUtil.d(TAG, "New level: " + newScanResult.level, sLoggingEnabled);
-                                mLogUtil.d(TAG, "comparison result: " + WifiManager.compareSignalLevel(newScanResult.level, scanResult.level), sLoggingEnabled);
+                                mLogUtil.d(TAG, "Current level: " + scanResult.level, loggingEnabled);
+                                mLogUtil.d(TAG, "New level: " + newScanResult.level, loggingEnabled);
+                                mLogUtil.d(TAG, "comparison result: " + WifiManager.compareSignalLevel(newScanResult.level, scanResult.level), loggingEnabled);
 
                                 if (WifiManager.compareSignalLevel(newScanResult.level, scanResult.level) > 0) {
-                                    mLogUtil.d(TAG, "New result has a higher signal strength, swapping", sLoggingEnabled);
+                                    mLogUtil.d(TAG, "New result has a higher signal strength, swapping", loggingEnabled);
                                     scanResultsToReturn.set(i, newScanResult);
                                 }
                             } else {
-                                mLogUtil.d(TAG, "SSID did not match", sLoggingEnabled);
+                                mLogUtil.d(TAG, "SSID did not match", loggingEnabled);
                             }
                         }
 
                         if (!found) {
-                            mLogUtil.d(TAG, "Found new wifi network", sLoggingEnabled);
+                            mLogUtil.d(TAG, "Found new wifi network", loggingEnabled);
                             scanResultsToReturn.add(newScanResult);
                         }
                     }
@@ -376,7 +393,7 @@ public List<ScanResult> getNearbyAccessPoints(Activity activity, boolean filterD
                 }
             }
         } else {
-            mLogUtil.w(TAG, "No activity to get nearby access points", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to get nearby access points", loggingEnabled);
 
         }
         return null;
@@ -396,7 +413,7 @@ public List<WifiConfiguration> getSavedNetworks(Activity activity) {
                 return wifiManager.getConfiguredNetworks();
             }
         } else {
-            mLogUtil.w(TAG, "No activity to get saved networks", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to get saved networks", loggingEnabled);
         }
         return null;
     }
@@ -455,7 +472,7 @@ public boolean isDeviceConnectedToMobileOrWifiNetwork(Activity activity) {
      */
     public boolean isDeviceConnectedToSSID(Activity activity, String ssid) {
         if (activity == null || activity.isFinishing()) {
-            mLogUtil.w(TAG, "Breaking due to no activity", sLoggingEnabled);
+            mLogUtil.w(TAG, "Breaking due to no activity", loggingEnabled);
             return false;
         }
         WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
@@ -463,16 +480,16 @@ public boolean isDeviceConnectedToSSID(Activity activity, String ssid) {
             WifiInfo connectionInfo = wifiManager.getConnectionInfo();
             if (connectionInfo != null && connectionInfo.getSSID() != null) {
                 String currentSSID = connectionInfo.getSSID().replaceAll("\"", "");
-                mLogUtil.d(TAG, "Current SSID: " + currentSSID, sLoggingEnabled);
+                mLogUtil.d(TAG, "Current SSID: " + currentSSID, loggingEnabled);
 
                 if (currentSSID.equals(ssid)) {
-                    mLogUtil.d(TAG, "Correct SSID", sLoggingEnabled);
+                    mLogUtil.d(TAG, "Correct SSID", loggingEnabled);
                     ConnectivityManager connectivityManager = mGetManagerUtil.getConnectivityManager(activity);
                     if (connectivityManager != null
                             && connectivityManager.getActiveNetworkInfo() != null
                             && connectivityManager.getActiveNetworkInfo().isAvailable()
                             && connectivityManager.getActiveNetworkInfo().isConnected()) {
-                        mLogUtil.d(TAG, "Network is connected", sLoggingEnabled);
+                        mLogUtil.d(TAG, "Network is connected", loggingEnabled);
                         return true;
                     }
                 }
@@ -517,7 +534,7 @@ public boolean isNetworkInConfigurationList(Activity activity, String ssid) {
                 return isNetworkInConfigurationList(wifiManager, ssid);
             }
         } else {
-            mLogUtil.w(TAG, "No activity to check if network is in configuration list", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to check if network is in configuration list", loggingEnabled);
         }
         return false;
     }
@@ -553,7 +570,7 @@ public boolean isWifiEnabled(Activity activity) {
                 return wifiManager.isWifiEnabled();
             }
         } else {
-            mLogUtil.w(TAG, "No activity to check if wifi is enabled", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to check if wifi is enabled", loggingEnabled);
         }
         return false;
     }
@@ -577,16 +594,16 @@ public boolean removeNetwork(Activity activity, String ssidToRemove) {
                         if (wifiConfiguration != null && wifiConfiguration.SSID != null) {
                             String ssidInList = wifiConfiguration.SSID.replaceAll("\"", "");
 
-                            mLogUtil.d(TAG, "Configured WiFi Network {index:" + i + ", ssidInList:" + ssidInList + "}", sLoggingEnabled);
+                            mLogUtil.d(TAG, "Configured WiFi Network {index:" + i + ", ssidInList:" + ssidInList + "}", loggingEnabled);
                             if (ssidInList.equals(ssidToRemove)) {
-                                mLogUtil.d(TAG, "Removing network: " + ssidToRemove, sLoggingEnabled);
+                                mLogUtil.d(TAG, "Removing network: " + ssidToRemove, loggingEnabled);
                                 wifiManager.disconnect();
                                 boolean result = wifiManager.removeNetwork(wifiConfiguration.networkId);
                                 if (result) {
-                                    mLogUtil.d(TAG, "Successfully removed network", sLoggingEnabled);
+                                    mLogUtil.d(TAG, "Successfully removed network", loggingEnabled);
                                     wifiManager.saveConfiguration();
                                 } else {
-                                    mLogUtil.d(TAG, "Failed to remove network", sLoggingEnabled);
+                                    mLogUtil.d(TAG, "Failed to remove network", loggingEnabled);
                                 }
                                 wifiManager.reconnect();
                                 return result;
@@ -596,9 +613,9 @@ public boolean removeNetwork(Activity activity, String ssidToRemove) {
                 }
 
             }
-            mLogUtil.w(TAG, "SSID to remove: " + ssidToRemove + " was not found in list to remove network", sLoggingEnabled);
+            mLogUtil.w(TAG, "SSID to remove: " + ssidToRemove + " was not found in list to remove network", loggingEnabled);
         } else {
-            mLogUtil.w(TAG, "No activity to remove network", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to remove network", loggingEnabled);
         }
         return false;
     }
@@ -608,22 +625,26 @@ public boolean removeNetwork(Activity activity, String ssidToRemove) {
      *
      * @param activity - The activity to use as context to retrieve a wifi manager via getSystemService
      * @param ssidToSearchFor - The ssid to search for
-     * @param timeout - The approximate number of seconds to keep searching for the SSID
+     * @param timeoutInMillis - The number of milliseconds to keep searching for the SSID
      *
      * @return String|null - The first SSID that contains the search ssid (if any, else null)
      */
-    public String searchForSSID(Activity activity, String ssidToSearchFor, int timeout) {
+    public String searchForSSID(Activity activity, String ssidToSearchFor, int timeoutInMillis) {
         if (activity != null && !activity.isFinishing()) {
             WifiManager wifiManager = mGetManagerUtil.getWiFiManager(activity);
             if (wifiManager != null) {
-                for (int x = 0; x < timeout; x++) {
-                    mLogUtil.d(TAG, "Scanning SSIDs, pass " + x, sLoggingEnabled);
+                int scanPass = 1;
+                long currentTime;
+                long endTime = System.currentTimeMillis() + timeoutInMillis;
+                LogUtil.getInstance().d(TAG, "End time (searchForSSID): " + endTime, loggingEnabled);
+                do {
+                    mLogUtil.d(TAG, "Scanning SSIDs, pass " + scanPass, loggingEnabled);
                     wifiManager.startScan();
                     List<ScanResult> networks = wifiManager.getScanResults();
                     for (ScanResult scanResult : networks) {
-                        mLogUtil.d(TAG, "scanResult.SSID: " + scanResult.SSID, sLoggingEnabled);
+                        mLogUtil.d(TAG, "scanResult.SSID: " + scanResult.SSID, loggingEnabled);
                         if (scanResult.SSID != null && (scanResult.SSID.toUpperCase().contains(ssidToSearchFor.toUpperCase()))) {
-                            mLogUtil.d(TAG, "Found match, SSID: " + scanResult.SSID, sLoggingEnabled);
+                            mLogUtil.d(TAG, "Found match, SSID: " + scanResult.SSID, loggingEnabled);
                             return scanResult.SSID;
                         }
                     }
@@ -633,35 +654,59 @@ public String searchForSSID(Activity activity, String ssidToSearchFor, int timeo
                     } catch (InterruptedException ie) {
                         // Do nothing
                     }
-                }
+                    currentTime = System.currentTimeMillis();
+                    LogUtil.getInstance().d(TAG, "Current time (searchForSSID): " + endTime, loggingEnabled);
+                    scanPass++;
+                } while(currentTime < endTime);
             }
         } else {
-            mLogUtil.w(TAG, "No activity to search for SSID", sLoggingEnabled);
+            mLogUtil.w(TAG, "No activity to search for SSID", loggingEnabled);
         }
         return null;
     }
 
+    /**
+     * To query if logging is enabled or disabled for a WiseFy instance
+     *
+     * @return boolean - If logging is enabled for the WiseFy instance
+     */
+    @VisibleForTesting
+    public boolean isLoggingEnabled() {
+        return loggingEnabled;
+    }
+
     /**
      * HELPERS
      */
 
     /**
+     * Used internally by addOpenNetwork, addWEPNetwork, and addWPA2Network to add and save a new wifi configuration
+     *
+     * @param wifiManager - A wifi manager instance to add the network
+     * @param wifiConfig - The network to configuration to add
      *
-     * @param wifiManager
-     * @param wifiConfig
-     * @return
+     * @return int - The return code from WifiManager for network creation (-1 for failure)
      */
     private int addNetwork(WifiManager wifiManager, WifiConfiguration wifiConfig) {
         int result = wifiManager.addNetwork(wifiConfig);
         if (result != WIFI_MANAGER_FAILURE) {
-            mLogUtil.d(TAG, "Successfully added network", sLoggingEnabled);
+            mLogUtil.d(TAG, "Successfully added network", loggingEnabled);
             wifiManager.saveConfiguration();
         } else {
-            mLogUtil.e(TAG, "Failed to add network", sLoggingEnabled);
+            mLogUtil.e(TAG, "Failed to add network", loggingEnabled);
         }
         return result;
     }
 
+    /**
+     * Used internally by addOpenNetwork, addWEPNetwork, addWPA2Network, and
+     * isNetworkInConfigurationList to see if an ssid is already saved (CASE SENSITIVE!)
+     *
+     * @param wifiManager - A wifi manager instance to search for the ssid
+     * @param ssid - The ssid to check for in the configured network list
+     *
+     * @return boolean - If the ssid was found in the configuration list
+     */
     private boolean isNetworkInConfigurationList(WifiManager wifiManager, String ssid) {
         List<WifiConfiguration> list = wifiManager.getConfiguredNetworks();
         if (list != null && list.size() > 0) {
@@ -669,31 +714,46 @@ private boolean isNetworkInConfigurationList(WifiManager wifiManager, String ssi
                 WifiConfiguration wifiConfiguration = list.get(i);
                 if (wifiConfiguration != null && wifiConfiguration.SSID != null) {
                     String ssidInList = wifiConfiguration.SSID.replaceAll("\"", "");
-                    mLogUtil.d(TAG, "SSID in list: " + ssidInList + ", SSID: " + ssid, sLoggingEnabled);
+                    mLogUtil.d(TAG, "SSID in list: " + ssidInList + ", SSID: " + ssid, loggingEnabled);
                     if (ssidInList.equals(ssid)) {
-                        mLogUtil.d(TAG, "Found SSID in list", sLoggingEnabled);
+                        mLogUtil.d(TAG, "Found SSID in list", loggingEnabled);
                         return true;
                     }
                 }
             }
         } else {
-            mLogUtil.w(TAG, "Found 0 configured networks", sLoggingEnabled);
+            mLogUtil.w(TAG, "Found 0 configured networks", loggingEnabled);
         }
         return false;
     }
 
-    private boolean waitToConnectToSSID(Activity activity, String ssid, int timeout) {
-        for (int x = 0; x < timeout; x++) {
+    /**
+     * Used internally by connectToNetwork to check if the device connects to
+     * a given SSID within a specified time (timeout is in millis)
+     *
+     * @param activity - The activity to use as context to retrieve a wifi manager via getSystemService
+     * @param ssid - The ssid to wait for the device to connect to
+     * @param timeoutInMillis - The number of milliseconds to wait
+     *
+     * @return boolean - If the device is connected to the ssid in the given time
+     */
+    private boolean waitToConnectToSSID(Activity activity, String ssid, int timeoutInMillis) {
+        long currentTime;
+        long endTime = System.currentTimeMillis() + timeoutInMillis;
+        LogUtil.getInstance().d(TAG, "End time (waitToConnectToSSID): " + endTime, loggingEnabled);
+        do {
             boolean result = isDeviceConnectedToSSID(activity, ssid);
             if (result) {
                 return result;
             }
             try {
                 Thread.sleep(1000);
-            } catch (InterruptedException e) {
+            } catch (InterruptedException ie) {
                 // Do nothing
             }
-        }
+            currentTime = System.currentTimeMillis();
+            LogUtil.getInstance().d(TAG, "Current time (waitToConnectToSSID): " + endTime, loggingEnabled);
+        } while(currentTime < endTime);
         return false;
     }
 }
\ No newline at end of file