run<T> method Null safety

Future<T?> run<T>(
  1. {required String key,
  2. required int duration,
  3. required T? callback(
      ),
    1. T? fallback(
        )?}
      )

      Implementation

      static Future<T?> run<T>({
        required String key,
        required int duration,
        required T? Function() callback,
        T? Function()? fallback,
      }) async {
        final preferences = await SharedPreferences.getInstance();
        final currentTime = DateTime.now().millisecondsSinceEpoch;
        final currentMonth = DateTime.now().month;
        final currentYear = DateTime.now().year;
      
        /// Run only Once
        if (duration == -2 && !preferences.containsKey(key)) {
          preferences.setString(key, 'once');
          return callback.call();
        }
      
        /// Run only Monthly
        if (duration == -1) {
          final monthMilliseconds =
              (Utils.daysInMonth(currentMonth, currentYear) * Const.day);
          if (preferences.containsKey(key)) {
            final savedTime = preferences.getInt(key)!;
      
            if (savedTime <= currentTime) {
              preferences.setInt(
                key,
                savedTime + monthMilliseconds,
              );
              return callback.call();
            }
            return fallback?.call();
          }
      
          preferences.setInt(
            key,
            currentTime + monthMilliseconds,
          );
          return callback.call();
        }
      
        /// Run only on every start of Month
        if (duration > 0 && duration < 12) {
          if (preferences.containsKey(key)) {
            final savedMonth = preferences.getInt(key)!;
      
            if (savedMonth != duration) {
              preferences.setInt(key, duration);
              return callback.call();
            }
            return fallback?.call();
          }
          preferences.setInt(key, duration);
          return callback.call();
        }
      
        /// Run any other once options
        if (duration != -2 && preferences.containsKey(key)) {
          final int savedTime = preferences.getInt(key)!;
          final difference = currentTime - savedTime;
      
          if (difference > duration) {
            preferences.setInt(key, currentTime);
            return callback.call();
          }
      
          return fallback?.call();
        }
      
        preferences.setInt(key, currentTime);
        return callback.call();
      }