How to use the @react-native-community/async-storage.getAllKeys function in @react-native-community/async-storage

export async function unsetUserLocally() {
  // Remove token
  await AsyncStorage.removeItem('token')
  await AsyncStorage.removeItem('user')

  // Clear cache
  const keys = await AsyncStorage.getAllKeys()
  const cacheKeys = keys.filter(k => k.indexOf('CACHE.KEY.') !== -1)
  if(cacheKeys.length) {
    await AsyncStorage.multiRemove(cacheKeys)
  }
}

clearDataCache = async () => {
    const { dispatch } = this.props

    // Get all keys
    try {
      const keys = await AsyncStorage.getAllKeys()

      // Clear keys except for user authentication keys
      const keysToClear = keys.filter(key => key !== 'token' && key !== 'user')
      if (keysToClear.length > 0) {
        await AsyncStorage.multiRemove(keysToClear)
        dispatch(messageShow('Data cache cleared successfully.'))
      } else {
        dispatch(messageShow('No cached data to clear.'))
      }
    } catch(e) {
      dispatch(messageShow('There was some error clearing the cache. Please try again.'))
    } finally {
      setTimeout(() => {
        dispatch(messageHide())
      }, config.message.error.timers.default)
    }

static clearData = async () => {
    await AsyncStorage.removeItem(DATA_SETTINGS);
    await AsyncStorage.removeItem(DATA_PIN_HASH);
    await AsyncStorage.removeItem(DATA_ASSETS);
    await AsyncStorage.removeItem(DATA_PRICES);
    await AsyncStorage.removeItem(DATA_PRICES_FETCHTIME);
    // remove transactions
    const keys = await AsyncStorage.getAllKeys();
    for (let k = 0; k < keys.length; k += 1) {
      const key = keys[k];
      if (key.includes(DATA_ASSET_HIST)) {
        await AsyncStorage.removeItem(key);
      }
    }
  };

async getAllUserTokenKeys(userId){
        const tokenKeyPrefix = BaseTokenItem.createTokenKeyPrefix(this.clientId, userId)
        console.info('getting tokens')
        let tokenKeys = []
        if (this.persistent) {
            let keys = await AsyncStorage.getAllKeys()
            for (const key of keys) {
                if (key.startsWith(tokenKeyPrefix)) tokenKeys.push(key)
            }
        } else {
            for (const key of Object.getOwnPropertyNames(this.cache)) {
                if (key.startsWith(tokenKeyPrefix)) tokenKeys.push(key)
            }
        }

        return tokenKeys
    }
}

const clearV4PersistedContents = () =>
  AsyncStorage.getAllKeys((err, keys) => {
    if (!err && keys && keys.length) {
      const keyPrefix = 'persist:root';
      const v5PersistKeys = keys.filter(key => key.indexOf(keyPrefix) === 0);
      if (v5PersistKeys.length) {
        AsyncStorage.multiRemove(v5PersistKeys, () => Promise.resolve());
      } else {
        const v4KeyPrefix = 'reduxPersist:';
        const v4PersistKeys = keys.filter(
          key => key.indexOf(v4KeyPrefix) === 0,
        );
        if (v4PersistKeys.length) {
          AsyncStorage.multiRemove(v4PersistKeys, () => Promise.resolve());
        }
      }
    }
    return Promise.resolve();

restoreCache = async () => {
    let cacheSize = 0;
    const keys = await AsyncStorage.getAllKeys();
    const cachedData = await AsyncStorage.multiGet(keys.filter(key => key.startsWith(CACHE_KEY)));
    const keysToDelete = [];
    cachedData.forEach(([key, data]) => {
      const parsedData = JSON.parse(data);

      if (parsedData == null) {
        keysToDelete.push(key);
        return;
      }

      const { queryID, variables } = JSON.parse(key.substring(CACHE_KEY.length));

      if (this.isCurrent(parsedData.fetchTime) && cacheSize < CACHE_SIZE) {
        this.cache.set(queryID, variables, parsedData.payload);
        cacheSize++;
      } else {

getAllKeys: (): Promise> => {
            return AsyncStorage.getAllKeys();
        },
        multiSet: (items: string[][]) => {

_getAndCreateUserKeyCache() {
    return AsyncStorage.getAllKeys()
      .then((allKeys) => {
        this._createUserKeyCache(allKeys);
      })
  }

getAllKeys() {
        return AsyncStorage
            .getAllKeys()
            .then((keys) => {
                return keys.filter((key) => key.startsWith(this.storageKey));
            });
    }

keys() {
		return AsyncStorage.getAllKeys();
	},