Das hier ist ein ApplicationIDProvider:
import 'package:patient_app/repositories/settings_repository.dart';
import 'package:uuid/uuid.dart';

class ApplicationIdProvider {
  static final ApplicationIdProvider _instance =
      ApplicationIdProvider._internal();

  factory ApplicationIdProvider() => _instance;

  ApplicationIdProvider._internal();

  SettingsRepository settingsRepository = SettingsRepository();

  Future<String> getApplicationId() async {
    String? applicationId = await settingsRepository.readApplicationId();
    if (applicationId != null) {
      return applicationId;
    }

    String uuid = const Uuid().v1();
    settingsRepository.storeApplicationId(uuid);
    return uuid;
  }
}
der Configuration_Provider. 
import 'dart:convert';

import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:patient_app/environment.dart';
import 'package:patient_app/models/api_configuration.dart';
import 'package:patient_app/repositories/settings_repository.dart';
import 'package:patient_app/services/remote_configuration_service.dart';

class ConfigurationProvider {
  static final ConfigurationProvider _instance =
      ConfigurationProvider._internal();

  factory ConfigurationProvider() => _instance;

  ConfigurationProvider._internal();

  Future<ApiConfiguration?> getApiConfiguration() async {
    if (kDebugMode) {
      // in dev mode, load config from json only
      return _loadFromJson();
    } else {
      return _loadFromRemote().onError((error, stackTrace) => _loadFromJson());
    }
  }

  Future<void> saveApiConfiguration(ApiConfiguration? apiConfiguration) async {
    if (apiConfiguration != null) {
      await SettingsRepository().storeApiConfiguration(apiConfiguration);
    }
  }

  Future<ApiConfiguration?> loadApiConfiguration() {
    return SettingsRepository().readApiConfiguration();
  }

  Future<ApiConfiguration> _loadFromRemote() async {
    return await RemoteConfigurationService()
        .getRemoteConfiguration()
        .timeout(const Duration(seconds: 3));
  }

  Future<ApiConfiguration> _loadFromJson() async {
    var content = await rootBundle.loadString(Environment.configurationAsset);
    var parsed = json.decode(content);
    return ApiConfiguration.fromJson(parsed);
  }
}

Settings_repository:
import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:intl/locale.dart' as intl;
import 'package:patient_app/models/api_configuration.dart';
import 'package:patient_app/repositories/secure_store.dart';

class SettingsRepository {
  static final SettingsRepository _instance = SettingsRepository._internal();

  factory SettingsRepository() => _instance;

  SettingsRepository._internal();

  static const _applicationIdStorageKey = 'pbeApplicationId';
  static const _localeStorageKey = 'pbeLocale';
  static const _apiConfigurationStorageKey = 'pbeApiConfiguration';

  static const _phoneAppLaunchPermission = 'phoneAppLaunchPermission';
  static const _mailAppLaunchPermission = 'mailAppLaunchPermission';
  static const _mapAppLaunchPermission = 'mapAppLaunchPermission';

  String? _applicationId;
  Locale? _locale;
  ApiConfiguration? _apiConfiguration;

  Future<void> store(String key, bool value) async {
    SecureStore().write(key, value.toString());
  }

  Future<bool?> read(String key) async {
    String? storedValue = await SecureStore().read(key);
    if (storedValue != null) {
      return storedValue.toLowerCase() == 'true';
    }
    return null;
  }

  Future<void> clear(String key) async {
    await SecureStore().delete(key);
  }

  Future<void> storeApplicationId(String applicationId) async {
    SecureStore().write(_applicationIdStorageKey, applicationId);
    _applicationId = applicationId;
  }

  Future<String?> readApplicationId() async {
    return _applicationId ??=
        await SecureStore().read(_applicationIdStorageKey);
  }

  Future<void> clearApplicationId() async {
    await SecureStore().delete(_applicationIdStorageKey);
    _applicationId = null;
  }

  Future<void> storeLocale(Locale locale) async {
    SecureStore().write(_localeStorageKey, locale.toLanguageTag());
    _locale = locale;
  }

  Future<Locale?> readLocale() async {
    if (_locale != null) {
      return _locale;
    }
    String? localeIdentifier = await SecureStore().read(_localeStorageKey);
    if (localeIdentifier != null) {
      // Flutter/Flutter Locale class does not have a parser method,
      // the intl package's LocaleParser is used instead
      // also see https://github.com/flutter/flutter/issues/55720
      intl.Locale? parsedLocale = intl.Locale.tryParse(localeIdentifier);
      if (parsedLocale != null) {
        return Locale.fromSubtags(
          languageCode: parsedLocale.languageCode,
          countryCode: parsedLocale.countryCode,
          scriptCode: parsedLocale.scriptCode,
        );
      }
    }
    return null;
  }

  Future<void> clearLocale() async {
    await SecureStore().delete(_localeStorageKey);
    _locale = null;
  }

  Future<void> storeApiConfiguration(ApiConfiguration apiConfiguration) async {
    await SecureStore().write(
        _apiConfigurationStorageKey, json.encode(apiConfiguration.toJson()));
    _apiConfiguration = apiConfiguration;
  }

  Future<ApiConfiguration?> readApiConfiguration() async {
    ApiConfiguration? apiConfiguration;

    String? apiConfigurationString =
        await SecureStore().read(_apiConfigurationStorageKey);
    if (apiConfigurationString != null) {
      try {
        apiConfiguration =
            ApiConfiguration.fromJson(json.decode(apiConfigurationString));
      } catch (e) {
        // do not prevent app start on failure, just delete old stored apiConfiguration
        await clearApiConfiguration();
      }
    }
    _apiConfiguration = apiConfiguration;
    return _apiConfiguration;
  }

  Future<void> clearApiConfiguration() async {
    await SecureStore().delete(_apiConfigurationStorageKey);
    _apiConfiguration = null;
  }
}

Es soll jetzt ein LaunchPermissionProvider geschrieben werden der wie die anderen Provider ist und mit Settings_Repository funktioniert. 

SettingsRepository (settings_repository.dart) um "store, read und clear" Methode für "launch permission" 
keys:
phoneAppLaunchPermission
mailAppLaunchPermission
mapAppLaunchPermission
store Methode bekommt einen boolean, konvertiert diesen nach String und speichert ihn
LaunchPermissionProvider (launch_permission_provider.dart) erstellen, der die sechs entsprechenden Methoden zum Speichern und Lesen der einzelnen Permission Flags enthält