I'm trying to create a simple subscription validation service, but i need help, since i'm still learning the library.

[Vittor-Javidan]

Hey guys, my app is suppose to work offline, and i'm trying to create a service that's connect to the app store (Currently only play store), to detect automatic if the user is a premium subscribe or a free user every time he first render the app home screen.

If its a premium subscribe, my app gives 4 days of Offline usage with premium resources enable in case user lose internet, and this time is refreshed every time the user goes to home screen.

Since i did not find a way to test a expired subscription, i want to know if the line of code const purchases = await getAvailablePurchases({ onlyIncludeActiveItems: true }); will return expired purchases, or just the ones that is really currently active. I know the method and its parameters explain itself, but i want just to be sure having someone confirmation to have less bugs as possible.

OBS 1:

• The method "loadPlan" is loaded only on the first render of app home screen, and i'm not caring too much about piracy, since is not so practical to piracy the localstorage constantly anyways. For now i'm not interested in purchase methods for the service, i want only to read if a subscription is active or not for the current month.

OBS 2:

• If you have tips about good practices in this library considering the context, will be really helpfull.

My service code:

import { Platform } from 'react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';
import * as Network from 'expo-network';
import {initConnection, endConnection, getAvailablePurchases } from 'react-native-iap';


type AppSubscribePlan = 'Free' | 'Premium'

export default class SubscriptionManager {

  private static OFFLINE_TIME_LOCAL_STORAGE_KEY = 'OfflineTime';
  private static userPlan: AppSubscribePlan = 'Free';

  static getPlan(): AppSubscribePlan {
    return this.userPlan;
  }

  static async loadPlan(o: {
    onFinish: (userPlan: AppSubscribePlan) => void
    onError: (errorMessage: string) => void
  }) {

    this.userPlan = 'Free';

    if (await this.hasInternetConection() === false) {
      await this.readOfflineAccess({
        offlinePlan: (userPlan) => o.onFinish(userPlan),
      });
      return;
    }

    try {

      if (Platform.OS === 'ios') {
        this.userPlan = 'Premium';
        o.onFinish(this.userPlan);
        return;
      }

      if (Platform.OS === 'android') {

        await initConnection();
        const purchases = await getAvailablePurchases({ onlyIncludeActiveItems: true });

        console.log(purchases);

        for (let i = 0; i < purchases.length; i++) {
          if (purchases[i].productId === 'premium') {
            this.userPlan = 'Premium';
            await this.saveOfflineAccess();
            break;
          }
        }

        if (this.userPlan !== 'Premium') {
          await this.removeOfflineAccess();
        }

        console.log(this.userPlan);

        o.onFinish(this.userPlan);
        await endConnection();
      }

    } catch (error) {
      if (error instanceof Error) {
        o.onError(error.message);
      }
    }
  }

  private static async readOfflineAccess(o: {
    offlinePlan: (userPlan: AppSubscribePlan) => void
  }): Promise<void> {
    try {

      const savedTimeSinceEpoch = await AsyncStorage.getItem(this.OFFLINE_TIME_LOCAL_STORAGE_KEY);

      if (savedTimeSinceEpoch !== null) {

        const savedTime = parseInt(savedTimeSinceEpoch, 10);
        const currentTime = Date.now();
        const timeDifference = currentTime - savedTime;
        const PREMIUM_OFFLINE_TIME_LIMIT = 4 * 24 * 60 * 60 * 1000; // 4 days

        if (timeDifference > 0 && timeDifference <= PREMIUM_OFFLINE_TIME_LIMIT) {
          this.userPlan = 'Premium';
        }
      }

      o.offlinePlan(this.userPlan);

    } catch (error) {
      o.offlinePlan('Free');
      alert('Could not read offline premium access');
    }
  }

  private static async saveOfflineAccess(): Promise<void> {
    try {
      await AsyncStorage.setItem(this.OFFLINE_TIME_LOCAL_STORAGE_KEY, `${Date.now()}`);
    } catch (error) {
      alert('Could not save offline premium access');
    }
  }

  private static async removeOfflineAccess(): Promise<void> {
    try {
      await AsyncStorage.removeItem(this.OFFLINE_TIME_LOCAL_STORAGE_KEY);
    } catch (error) {
      alert('Could not remove offline premium access');
    }
  }

  private static async hasInternetConection(): Promise<boolean> {
    return (await Network.getNetworkStateAsync()).isInternetReachable ?? false;
  }
}