use react native keystore instead of expo secure store

__mocks__/react-native-keychain/index.js

+const keychainMock = {
+    SECURITY_LEVEL_ANY: "MOCK_SECURITY_LEVEL_ANY",
+    SECURITY_LEVEL_SECURE_SOFTWARE: "MOCK_SECURITY_LEVEL_SECURE_SOFTWARE",
+    SECURITY_LEVEL_SECURE_HARDWARE: "MOCK_SECURITY_LEVEL_SECURE_HARDWARE",
+}
+
+export default keychainMock;

__tests__/managers/ConnectionManager.test.js

+jest.mock('react-native-keychain');
+
 import React from 'react';
 import ConnectionManager from "../../src/managers/ConnectionManager";
 import {ERROR_TYPE} from "../../src/utils/WebData";
-import * as SecureStore from 'expo-secure-store';
 
 let fetch = require('isomorphic-fetch'); // fetch is not implemented in nodeJS but in react-native
 
     return expect(c.isLoggedIn()).toBe(false);
 });
 
-test('recoverLogin error crypto', () => {
-    jest.spyOn(SecureStore, 'getItemAsync').mockImplementationOnce(() => {
-        return Promise.reject();
-    });
-    return expect(c.recoverLogin()).rejects.toBe(false);
-});
-
-test('recoverLogin success crypto', () => {
-    jest.spyOn(SecureStore, 'getItemAsync').mockImplementationOnce(() => {
-        return Promise.resolve('token1');
-    });
-    return expect(c.recoverLogin()).resolves.toBe('token1');
-});
-
-test('saveLogin success', () => {
-    jest.spyOn(SecureStore, 'setItemAsync').mockImplementationOnce(() => {
-        return Promise.resolve();
-    });
-    return expect(c.saveLogin('email', 'token2')).resolves.toBeTruthy();
-});
-
-test('saveLogin error', () => {
-    jest.spyOn(SecureStore, 'setItemAsync').mockImplementationOnce(() => {
-        return Promise.reject();
-    });
-    return expect(c.saveLogin('email', 'token3')).rejects.toBeFalsy();
-});
-
-test('recoverLogin error crypto with saved token', () => {
-    jest.spyOn(SecureStore, 'getItemAsync').mockImplementationOnce(() => {
-        return Promise.reject();
-    });
-    return expect(c.recoverLogin()).resolves.toBe('token2');
-});
-
-test('recoverLogin success saved', () => {
-    return expect(c.recoverLogin()).resolves.toBe('token2');
-});
-
 test("isConnectionResponseValid", () => {
     let json = {
         error: 0,

package.json

     "expo": "^37.0.0",
     "expo-barcode-scanner": "~8.1.0",
     "expo-camera": "latest",
-    "expo-secure-store": "~8.1.0",
     "i18n-js": "^3.3.0",
     "react": "~16.9.0",
     "react-dom": "16.9.0",
     "react-native-collapsible": "^1.5.2",
     "react-native-gesture-handler": "~1.6.0",
     "react-native-image-modal": "^1.0.6",
+    "react-native-keychain": "^6.0.0",
     "react-native-linear-gradient": "^2.5.6",
     "react-native-localize": "^1.4.0",
     "react-native-modalize": "^1.3.6",

src/managers/ConnectionManager.js

 // @flow
 
-import * as SecureStore from 'expo-secure-store';
+import * as Keychain from 'react-native-keychain';
 import {apiRequest, ERROR_TYPE, isResponseValid} from "../utils/WebData";
 
 /**
  * 500 : SERVER_ERROR -> pb coté serveur
  */
 
-
+const SERVER_NAME = "amicale-insat.fr";
 const AUTH_PATH = "password";
 
 export default class ConnectionManager {
             if (this.getToken() !== null)
                 resolve(this.getToken());
             else {
-                SecureStore.getItemAsync('token')
-                    .then((token) => {
-                        this.#token = token;
-                        if (token !== null) {
+                Keychain.getInternetCredentials(SERVER_NAME)
+                    .then((data) => {
+                        if (data) {
+                            this.#token = data.password;
                             this.onLoginStateChange(true);
-                            resolve(token);
+                            resolve(this.#token);
                         } else
                             reject(false);
                     })
-                    .catch(error => {
+                    .catch(() => {
                         reject(false);
                     });
             }
 
     async saveLogin(email: string, token: string) {
         return new Promise((resolve, reject) => {
-            SecureStore.setItemAsync('token', token)
+            Keychain.setInternetCredentials(SERVER_NAME, 'token', token)
                 .then(() => {
                     this.#token = token;
                     this.#email = email;
                     this.onLoginStateChange(true);
                     resolve(true);
                 })
-                .catch(error => {
+                .catch(() => {
                     reject(false);
                 });
         });
 
     async disconnect() {
         return new Promise((resolve, reject) => {
-            SecureStore.deleteItemAsync('token')
+            Keychain.resetInternetCredentials(SERVER_NAME)
                 .then(() => {
                     this.#token = null;
                     this.onLoginStateChange(false);
                     resolve(true);
                 })
-                .catch((error) => {
+                .catch(() => {
                     reject(false);
                 });
         });