#175

pending completion

Build # #175

Build Type

push

github-actions

Committed by

web-flow

Commit Message

Merge pull request #921 from opensrp/refactor-user-settings-task

Refactor user settings task

Run Details

18309 of 26768 relevant lines covered (68.4%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.27

opensrp-core/src/main/java/org/smartregister/CoreLibrary.java

package org.smartregister;

import static androidx.preference.PreferenceManager.getDefaultSharedPreferences;

import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.OnAccountsUpdateListener;
import android.content.Intent;
import android.content.SharedPreferences;
import android.text.TextUtils;

import androidx.annotation.Nullable;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;

import org.apache.commons.lang3.StringUtils;
import org.smartregister.account.AccountAuthenticatorXml;
import org.smartregister.authorizer.P2PSyncAuthorizationService;
import org.smartregister.p2p.P2PLibrary;
import org.smartregister.pathevaluator.PathEvaluatorLibrary;
import org.smartregister.repository.AllSharedPreferences;
import org.smartregister.repository.P2PReceiverTransferDao;
import org.smartregister.repository.P2PSenderTransferDao;
import org.smartregister.repository.TaskNotesRepository;
import org.smartregister.repository.dao.ClientDaoImpl;
import org.smartregister.repository.dao.EventDaoImpl;
import org.smartregister.repository.dao.LocationDaoImpl;
import org.smartregister.repository.dao.TaskDaoImpl;
import org.smartregister.sync.P2PSyncFinishCallback;
import org.smartregister.util.CredentialsHelper;
import org.smartregister.util.Utils;

import java.util.Map;
import java.util.Set;

import timber.log.Timber;

/**
 * Created by keyman on 31/07/17.
 */
public class CoreLibrary implements OnAccountsUpdateListener {

    private static CoreLibrary instance;
    private static long buildTimeStamp;
    private static String ENCRYPTED_PREFS_KEY_KEYSET = "__androidx_security_crypto_encrypted_prefs_key_keyset__";
    private static String ENCRYPTED_PREFS_VALUE_KEYSET = "__androidx_security_crypto_encrypted_prefs_value_keyset__";
    private final Context context;
    private final SyncConfiguration syncConfiguration;
    private boolean isPeerToPeerProcessing = false;
    private String ecClientFieldsFile = "ec_client_fields.json";
    private P2POptions p2POptions;
    private AccountManager accountManager;
    private AccountAuthenticatorXml authenticatorXml;

    protected CoreLibrary(Context contextArg, SyncConfiguration syncConfiguration, @Nullable P2POptions p2POptions) {
        context = contextArg;
        this.syncConfiguration = syncConfiguration;
        this.p2POptions = p2POptions;

        initP2pLibrary(null);
        if (syncConfiguration != null && syncConfiguration.runPlanEvaluationOnClientProcessing()) {
            PathEvaluatorLibrary.init(new LocationDaoImpl(), new ClientDaoImpl(), new TaskDaoImpl(new TaskNotesRepository()), new EventDaoImpl());
        }
    }

    public static void init(Context context) {
        init(context, null);
    }

    public static void init(Context context, SyncConfiguration syncConfiguration) {
        init(context, syncConfiguration, BuildConfig.BUILD_TIMESTAMP);
    }

    public static void init(Context context, SyncConfiguration syncConfiguration, long buildTimestamp) {
        init(context, syncConfiguration, buildTimestamp, null);
    }

    public static void init(Context context, SyncConfiguration syncConfiguration, long buildTimestamp, @Nullable P2POptions options) {
        if (instance == null) {
            instance = new CoreLibrary(context, syncConfiguration, options);
            buildTimeStamp = buildTimestamp;
            upgradeSharedPreferences();
            checkPlatformMigrations();
        }
    }

    public static void destroyInstance() {
        instance = null;
    }

    private static void checkPlatformMigrations() {
        boolean shouldMigrate = CredentialsHelper.shouldMigrate();
        if (shouldMigrate && StringUtils.isNotBlank(instance.context().userService().getAllSharedPreferences().fetchPioneerUser())) {//Force remote login
            Utils.logoutUser(instance.context(), instance.context().applicationContext().getString(R.string.new_db_encryption_version_migration));
        }
        instance.context().userService().getAllSharedPreferences().migratePassphrase();
    }

    /**
     * Check encrypted prefs sync configuration
     * If configured to encrypt and there are previously saved shared prefs, recreate them encrypted
     * If configured not to encrypt but previous version encrypted, clear the prefs
     */
    private static void upgradeSharedPreferences() {
        try {
            android.content.Context appContext = instance.context().applicationContext();
            SharedPreferences existingPrefs = appContext.getSharedPreferences(appContext.getPackageName() + "_preferences", android.content.Context.MODE_PRIVATE);
            Map<String, ?> entries = existingPrefs.getAll();

            // check the version of SharedPreferences (encrypted vs unencrypted)
            // as well as whether encryption key-value pair is set
            if (Utils.getBooleanProperty(AllConstants.PROPERTY.ENCRYPT_SHARED_PREFERENCES)
                    && !entries.containsKey(ENCRYPTED_PREFS_KEY_KEYSET)
                    && !entries.containsKey(ENCRYPTED_PREFS_VALUE_KEYSET)) {

                existingPrefs.edit().clear().apply();

                // create the new instance
                SharedPreferences newPrefs = instance.context().allSharedPreferences().getPreferences();

                copySharedPreferences(entries, newPrefs);
            }
        } catch (Exception e) {
            Timber.e(e);
        }
    }

    private static void copySharedPreferences(Map<String, ?> entries, SharedPreferences preferences) {
        try {
            for (Map.Entry<String, ?> entry : entries.entrySet()) {
                if (entry.getValue() instanceof Boolean) {
                    preferences.edit().putBoolean(entry.getKey(), (Boolean) entry.getValue()).apply();
                } else if (entry.getValue() instanceof Float) {
                    preferences.edit().putFloat(entry.getKey(), (Float) entry.getValue()).apply();
                } else if (entry.getValue() instanceof Integer) {
                    preferences.edit().putInt(entry.getKey(), (Integer) entry.getValue()).apply();
                } else if (entry.getValue() instanceof Long) {
                    preferences.edit().putLong(entry.getKey(), (Long) entry.getValue()).apply();
                } else if (entry.getValue() instanceof String) {
                    preferences.edit().putString(entry.getKey(), (String) entry.getValue()).apply();
                } else if (entry.getValue() instanceof Set) {
                    preferences.edit().putStringSet(entry.getKey(), (Set) entry.getValue()).apply();
                }
            }
        } catch (Exception e) {
            Timber.e(e, "Failed to save SharedPreference");
        }
    }

    public static CoreLibrary getInstance() {
        if (instance == null) {
            throw new IllegalStateException(" Instance does not exist!!! Call "
                    + CoreLibrary.class.getName()
                    + ".init method in the onCreate method of "
                    + "your Application class ");
        }
        return instance;
    }

    /**
     * Use this method when testing.
     * It should replace org.smartregister.Context#setInstance(org.smartregister.Context) which has been removed
     *
     * @param context
     */
    public static void reset(Context context) {
        if (context != null) {
            instance = new CoreLibrary(context, null, null);
        }
    }

    public static void reset(Context context, SyncConfiguration syncConfiguration) {
        if (context != null) {
            instance = new CoreLibrary(context, syncConfiguration, null);
        }
    }

    public static long getBuildTimeStamp() {
        return buildTimeStamp;
    }

    public static boolean isTimecheckDisabled() {
        return AllConstants.TIME_CHECK;
    }

    public void initP2pLibrary(@Nullable String username) {
        if (p2POptions != null && p2POptions.isEnableP2PLibrary()) {
            String p2pUsername = username;
            AllSharedPreferences allSharedPreferences = new AllSharedPreferences(getDefaultSharedPreferences(context.applicationContext()));
            if (p2pUsername == null) {
                p2pUsername = allSharedPreferences.fetchRegisteredANM();
            }

            if (!TextUtils.isEmpty(p2pUsername)) {
                String teamId = allSharedPreferences.fetchDefaultTeamId(p2pUsername);

                if (p2POptions.getAuthorizationService() == null) {
                    p2POptions.setAuthorizationService(new P2PSyncAuthorizationService(teamId));
                }

                if (p2POptions.getReceiverTransferDao() == null) {
                    p2POptions.setReceiverTransferDao(new P2PReceiverTransferDao());
                }

                if (p2POptions.getSenderTransferDao() == null) {
                    p2POptions.setSenderTransferDao(new P2PSenderTransferDao());
                }

                if (p2POptions.getSyncFinishedCallback() == null) {
                    p2POptions.setSyncFinishedCallback(new P2PSyncFinishCallback());
                }

                P2PLibrary.Options options = new P2PLibrary.Options(context.applicationContext()
                        , teamId, p2pUsername, p2POptions.getAuthorizationService(), p2POptions.getReceiverTransferDao()
                        , p2POptions.getSenderTransferDao());
                options.setBatchSize(p2POptions.getBatchSize());
                options.setSyncFinishedCallback(p2POptions.getSyncFinishedCallback());
                options.setRecalledIdentifier(p2POptions.getRecalledIdentifier());

                P2PLibrary.init(options);
            }
        }
    }

    public Context context() {
        return context;
    }

    @Nullable
    public SyncConfiguration getSyncConfiguration() {
        return syncConfiguration;
    }

    public AccountManager getAccountManager() {
        if (accountManager == null) {
            accountManager = AccountManager.get(context.applicationContext());
            accountManager.addOnAccountsUpdatedListener(this, null, true);
        }

        return accountManager;
    }

    public AccountAuthenticatorXml getAccountAuthenticatorXml() {
        if (authenticatorXml == null)
            authenticatorXml = Utils.parseAuthenticatorXMLConfigData(context.applicationContext());

        return authenticatorXml;
    }

    public String getEcClientFieldsFile() {
        return ecClientFieldsFile;
    }

    public void setEcClientFieldsFile(String ecClientFieldsFile) {
        this.ecClientFieldsFile = ecClientFieldsFile;
    }

    @Nullable
    public P2POptions getP2POptions() {
        return p2POptions;
    }

    public boolean isPeerToPeerProcessing() {
        return isPeerToPeerProcessing;
    }

    public void setPeerToPeerProcessing(boolean peerToPeerProcessing) {
        isPeerToPeerProcessing = peerToPeerProcessing;

        sendPeerToPeerProcessingStatus(isPeerToPeerProcessing);
    }

    private void sendPeerToPeerProcessingStatus(boolean status) {
        Intent intent = new Intent();
        intent.setAction(AllConstants.PeerToPeer.PROCESSING_ACTION);
        intent.putExtra(AllConstants.PeerToPeer.KEY_IS_PROCESSING, status);

        LocalBroadcastManager.getInstance(context.applicationContext())
                .sendBroadcast(intent);
    }

    @Override
    public void onAccountsUpdated(Account[] accounts) {
        if (context.allSharedPreferences().getDBEncryptionVersion() > 0) {
            try {
                String loggedInUser = context.allSharedPreferences().fetchRegisteredANM();

                if (!StringUtils.isBlank(loggedInUser)) {

                    boolean accountExists = false;

                    for (Account account : accounts) {
                        if (account.type.equals(getAccountAuthenticatorXml().getAccountType()) && account.name.equals(context.allSharedPreferences().fetchRegisteredANM())) {
                            accountExists = true;
                            break;
                        }
                    }

                    if (!accountExists) {

                        Utils.logoutUser(context, context.applicationContext().getString(R.string.account_removed));

                    }
                }
            } catch (Exception e) {
                Timber.e(e);
            }
        }
    }
}

1	package org.smartregister;
2
3	import static androidx.preference.PreferenceManager.getDefaultSharedPreferences;
4
5	import android.accounts.Account;
6	import android.accounts.AccountManager;
7	import android.accounts.OnAccountsUpdateListener;
8	import android.content.Intent;
9	import android.content.SharedPreferences;
10	import android.text.TextUtils;
11
12	import androidx.annotation.Nullable;
13	import androidx.localbroadcastmanager.content.LocalBroadcastManager;
14
15	import org.apache.commons.lang3.StringUtils;
16	import org.smartregister.account.AccountAuthenticatorXml;
17	import org.smartregister.authorizer.P2PSyncAuthorizationService;
18	import org.smartregister.p2p.P2PLibrary;
19	import org.smartregister.pathevaluator.PathEvaluatorLibrary;
20	import org.smartregister.repository.AllSharedPreferences;
21	import org.smartregister.repository.P2PReceiverTransferDao;
22	import org.smartregister.repository.P2PSenderTransferDao;
23	import org.smartregister.repository.TaskNotesRepository;
24	import org.smartregister.repository.dao.ClientDaoImpl;
25	import org.smartregister.repository.dao.EventDaoImpl;
26	import org.smartregister.repository.dao.LocationDaoImpl;
27	import org.smartregister.repository.dao.TaskDaoImpl;
28	import org.smartregister.sync.P2PSyncFinishCallback;
29	import org.smartregister.util.CredentialsHelper;
30	import org.smartregister.util.Utils;
31
32	import java.util.Map;
33	import java.util.Set;
34
35	import timber.log.Timber;
36
37	/**
38	* Created by keyman on 31/07/17.
39	*/
40	public class CoreLibrary implements OnAccountsUpdateListener {
41
42	private static CoreLibrary instance;
43	private static long buildTimeStamp;
44	private static String ENCRYPTED_PREFS_KEY_KEYSET = "__androidx_security_crypto_encrypted_prefs_key_keyset__";	1✔
45	private static String ENCRYPTED_PREFS_VALUE_KEYSET = "__androidx_security_crypto_encrypted_prefs_value_keyset__";	1✔
46	private final Context context;
47	private final SyncConfiguration syncConfiguration;
48	private boolean isPeerToPeerProcessing = false;	1✔
49	private String ecClientFieldsFile = "ec_client_fields.json";	1✔
50	private P2POptions p2POptions;
51	private AccountManager accountManager;
52	private AccountAuthenticatorXml authenticatorXml;
53
54	protected CoreLibrary(Context contextArg, SyncConfiguration syncConfiguration, @Nullable P2POptions p2POptions) {	1✔
55	context = contextArg;	1✔
56	this.syncConfiguration = syncConfiguration;	1✔
57	this.p2POptions = p2POptions;	1✔
58
59	initP2pLibrary(null);	1✔
60	if (syncConfiguration != null && syncConfiguration.runPlanEvaluationOnClientProcessing()) {	1✔
61	PathEvaluatorLibrary.init(new LocationDaoImpl(), new ClientDaoImpl(), new TaskDaoImpl(new TaskNotesRepository()), new EventDaoImpl());	1✔
62	}
63	}	1✔
64
65	public static void init(Context context) {
66	init(context, null);	1✔
67	}	1✔
68
69	public static void init(Context context, SyncConfiguration syncConfiguration) {
70	init(context, syncConfiguration, BuildConfig.BUILD_TIMESTAMP);	1✔
71	}	1✔
72
73	public static void init(Context context, SyncConfiguration syncConfiguration, long buildTimestamp) {
74	init(context, syncConfiguration, buildTimestamp, null);	1✔
75	}	1✔
76
77	public static void init(Context context, SyncConfiguration syncConfiguration, long buildTimestamp, @Nullable P2POptions options) {
78	if (instance == null) {	1✔
79	instance = new CoreLibrary(context, syncConfiguration, options);	1✔
80	buildTimeStamp = buildTimestamp;	1✔
81	upgradeSharedPreferences();	1✔
82	checkPlatformMigrations();	1✔
83	}
84	}	1✔
85
86	public static void destroyInstance() {
87	instance = null;	1✔
88	}	1✔
89
90	private static void checkPlatformMigrations() {
91	boolean shouldMigrate = CredentialsHelper.shouldMigrate();	1✔
92	if (shouldMigrate && StringUtils.isNotBlank(instance.context().userService().getAllSharedPreferences().fetchPioneerUser())) {//Force remote login	1✔
93	Utils.logoutUser(instance.context(), instance.context().applicationContext().getString(R.string.new_db_encryption_version_migration));	1✔
94	}
95	instance.context().userService().getAllSharedPreferences().migratePassphrase();	1✔
96	}	1✔
97
98	/**
99	* Check encrypted prefs sync configuration
100	* If configured to encrypt and there are previously saved shared prefs, recreate them encrypted
101	* If configured not to encrypt but previous version encrypted, clear the prefs
102	*/
103	private static void upgradeSharedPreferences() {
104	try {
105	android.content.Context appContext = instance.context().applicationContext();	1✔
106	SharedPreferences existingPrefs = appContext.getSharedPreferences(appContext.getPackageName() + "_preferences", android.content.Context.MODE_PRIVATE);	1✔
107	Map<String, ?> entries = existingPrefs.getAll();	1✔
108
109	// check the version of SharedPreferences (encrypted vs unencrypted)
110	// as well as whether encryption key-value pair is set
111	if (Utils.getBooleanProperty(AllConstants.PROPERTY.ENCRYPT_SHARED_PREFERENCES)	1✔
112	&& !entries.containsKey(ENCRYPTED_PREFS_KEY_KEYSET)	1✔
113	&& !entries.containsKey(ENCRYPTED_PREFS_VALUE_KEYSET)) {	1✔
114
115	existingPrefs.edit().clear().apply();	1✔
116
117	// create the new instance
118	SharedPreferences newPrefs = instance.context().allSharedPreferences().getPreferences();	1✔
119
120	copySharedPreferences(entries, newPrefs);	1✔
121	}
122	} catch (Exception e) {	×
123	Timber.e(e);	×
124	}	1✔
125	}	1✔
126
127	private static void copySharedPreferences(Map<String, ?> entries, SharedPreferences preferences) {
128	try {
129	for (Map.Entry<String, ?> entry : entries.entrySet()) {	1✔
130	if (entry.getValue() instanceof Boolean) {	1✔
131	preferences.edit().putBoolean(entry.getKey(), (Boolean) entry.getValue()).apply();	1✔
132	} else if (entry.getValue() instanceof Float) {	1✔
133	preferences.edit().putFloat(entry.getKey(), (Float) entry.getValue()).apply();	1✔
134	} else if (entry.getValue() instanceof Integer) {	1✔
135	preferences.edit().putInt(entry.getKey(), (Integer) entry.getValue()).apply();	1✔
136	} else if (entry.getValue() instanceof Long) {	1✔
137	preferences.edit().putLong(entry.getKey(), (Long) entry.getValue()).apply();	1✔
138	} else if (entry.getValue() instanceof String) {	1✔
139	preferences.edit().putString(entry.getKey(), (String) entry.getValue()).apply();	1✔
140	} else if (entry.getValue() instanceof Set) {	1✔
141	preferences.edit().putStringSet(entry.getKey(), (Set) entry.getValue()).apply();	1✔
142	}
143	}	1✔
144	} catch (Exception e) {	1✔
145	Timber.e(e, "Failed to save SharedPreference");	1✔
146	}	1✔
147	}	1✔
148
149	public static CoreLibrary getInstance() {
150	if (instance == null) {	1✔
151	throw new IllegalStateException(" Instance does not exist!!! Call "	1✔
152	+ CoreLibrary.class.getName()	1✔
153	+ ".init method in the onCreate method of "
154	+ "your Application class ");
155	}
156	return instance;	1✔
157	}
158
159	/**
160	* Use this method when testing.
161	* It should replace org.smartregister.Context#setInstance(org.smartregister.Context) which has been removed
162	*
163	* @param context
164	*/
165	public static void reset(Context context) {
166	if (context != null) {	1✔
167	instance = new CoreLibrary(context, null, null);	1✔
168	}
169	}	1✔
170
171	public static void reset(Context context, SyncConfiguration syncConfiguration) {
172	if (context != null) {	1✔
173	instance = new CoreLibrary(context, syncConfiguration, null);	1✔
174	}
175	}	1✔
176
177	public static long getBuildTimeStamp() {
178	return buildTimeStamp;	1✔
179	}
180
181	public static boolean isTimecheckDisabled() {
182	return AllConstants.TIME_CHECK;	×
183	}
184
185	public void initP2pLibrary(@Nullable String username) {
186	if (p2POptions != null && p2POptions.isEnableP2PLibrary()) {	1✔
187	String p2pUsername = username;	1✔
188	AllSharedPreferences allSharedPreferences = new AllSharedPreferences(getDefaultSharedPreferences(context.applicationContext()));	1✔
189	if (p2pUsername == null) {	1✔
190	p2pUsername = allSharedPreferences.fetchRegisteredANM();	1✔
191	}
192
193	if (!TextUtils.isEmpty(p2pUsername)) {	1✔
194	String teamId = allSharedPreferences.fetchDefaultTeamId(p2pUsername);	1✔
195
196	if (p2POptions.getAuthorizationService() == null) {	1✔
197	p2POptions.setAuthorizationService(new P2PSyncAuthorizationService(teamId));	1✔
198	}
199
200	if (p2POptions.getReceiverTransferDao() == null) {	1✔
201	p2POptions.setReceiverTransferDao(new P2PReceiverTransferDao());	1✔
202	}
203
204	if (p2POptions.getSenderTransferDao() == null) {	1✔
205	p2POptions.setSenderTransferDao(new P2PSenderTransferDao());	1✔
206	}
207
208	if (p2POptions.getSyncFinishedCallback() == null) {	1✔
209	p2POptions.setSyncFinishedCallback(new P2PSyncFinishCallback());	1✔
210	}
211
212	P2PLibrary.Options options = new P2PLibrary.Options(context.applicationContext()	1✔
213	, teamId, p2pUsername, p2POptions.getAuthorizationService(), p2POptions.getReceiverTransferDao()	1✔
214	, p2POptions.getSenderTransferDao());	1✔
215	options.setBatchSize(p2POptions.getBatchSize());	1✔
216	options.setSyncFinishedCallback(p2POptions.getSyncFinishedCallback());	1✔
217	options.setRecalledIdentifier(p2POptions.getRecalledIdentifier());	1✔
218
219	P2PLibrary.init(options);	1✔
220	}
221	}
222	}	1✔
223
224	public Context context() {
225	return context;	1✔
226	}
227
228	@Nullable
229	public SyncConfiguration getSyncConfiguration() {
230	return syncConfiguration;	1✔
231	}
232
233	public AccountManager getAccountManager() {
234	if (accountManager == null) {	1✔
235	accountManager = AccountManager.get(context.applicationContext());	1✔
236	accountManager.addOnAccountsUpdatedListener(this, null, true);	1✔
237	}
238
239	return accountManager;	1✔
240	}
241
242	public AccountAuthenticatorXml getAccountAuthenticatorXml() {
243	if (authenticatorXml == null)	1✔
244	authenticatorXml = Utils.parseAuthenticatorXMLConfigData(context.applicationContext());	1✔
245
246	return authenticatorXml;	1✔
247	}
248
249	public String getEcClientFieldsFile() {
250	return ecClientFieldsFile;	1✔
251	}
252
253	public void setEcClientFieldsFile(String ecClientFieldsFile) {
254	this.ecClientFieldsFile = ecClientFieldsFile;	1✔
255	}	1✔
256
257	@Nullable
258	public P2POptions getP2POptions() {
259	return p2POptions;	1✔
260	}
261
262	public boolean isPeerToPeerProcessing() {
263	return isPeerToPeerProcessing;	1✔
264	}
265
266	public void setPeerToPeerProcessing(boolean peerToPeerProcessing) {
267	isPeerToPeerProcessing = peerToPeerProcessing;	1✔
268
269	sendPeerToPeerProcessingStatus(isPeerToPeerProcessing);	1✔
270	}	1✔
271
272	private void sendPeerToPeerProcessingStatus(boolean status) {
273	Intent intent = new Intent();	1✔
274	intent.setAction(AllConstants.PeerToPeer.PROCESSING_ACTION);	1✔
275	intent.putExtra(AllConstants.PeerToPeer.KEY_IS_PROCESSING, status);	1✔
276
277	LocalBroadcastManager.getInstance(context.applicationContext())	1✔
278	.sendBroadcast(intent);	1✔
279	}	1✔
280
281	@Override
282	public void onAccountsUpdated(Account[] accounts) {
283	if (context.allSharedPreferences().getDBEncryptionVersion() > 0) {	1✔
284	try {
285	String loggedInUser = context.allSharedPreferences().fetchRegisteredANM();	1✔
286
287	if (!StringUtils.isBlank(loggedInUser)) {	1✔
288
289	boolean accountExists = false;	1✔
290
291	for (Account account : accounts) {	1✔
292	if (account.type.equals(getAccountAuthenticatorXml().getAccountType()) && account.name.equals(context.allSharedPreferences().fetchRegisteredANM())) {	1✔
293	accountExists = true;	1✔
294	break;	1✔
295	}
296	}
297
298	if (!accountExists) {	1✔
299
300	Utils.logoutUser(context, context.applicationContext().getString(R.string.account_removed));	1✔
301
302	}
303	}
304	} catch (Exception e) {	×
305	Timber.e(e);	×
306	}	1✔
307	}
308	}	1✔
309	}

opensrp / opensrp-client-core / #175

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous