From 0c6731d6b8f25972b308f97f3ecafb2b7f3dd300 Mon Sep 17 00:00:00 2001 From: Nirvana Date: Tue, 25 Nov 2025 10:53:10 +0100 Subject: [PATCH] Obey provider enabled setting --- lib/streaming_providers/base/manager.py | 56 ++++++++++++++----- .../base/settings/settings_manager.py | 40 +++++++++++++ 2 files changed, 83 insertions(+), 13 deletions(-) diff --git a/lib/streaming_providers/base/manager.py b/lib/streaming_providers/base/manager.py index 48a059e..3fa985b 100644 --- a/lib/streaming_providers/base/manager.py +++ b/lib/streaming_providers/base/manager.py @@ -17,6 +17,27 @@ class ProviderManager: self.drm_plugin_manager = DRMPluginManager() logger.info("ProviderManager: Initialized with DRM plugin manager") + @staticmethod + def _is_provider_enabled(provider_name: str, country: Optional[str] = None) -> bool: + """ + Check if a provider is enabled via settings manager. + + Args: + provider_name: Name of the provider + country: Optional country code + + Returns: + True if provider is enabled, False otherwise + """ + try: + from .settings.settings_manager import SettingsManager + # Create or get existing settings manager + settings_manager = SettingsManager() + return settings_manager.is_provider_enabled(provider_name, country) + except Exception as e: + logger.warning(f"Could not check enable status for '{provider_name}': {e}, defaulting to enabled") + return True + def register_provider(self, provider: StreamingProvider) -> None: """ Register a single provider instance. @@ -43,17 +64,6 @@ class ProviderManager: self.register_provider(provider) def discover_providers(self, country: str = 'DE', detected_providers: Dict[str, List[str]] = None) -> List[str]: - """ - Discover and register all available providers for a country. - - Args: - country: Country code for provider configuration (used as fallback) - detected_providers: Optional dict mapping provider names to country lists. - If None, falls back to discovering all AVAILABLE_PROVIDERS. - - Returns: - List of discovered provider names (without country suffixes for compatibility) - """ from streaming_providers import AVAILABLE_PROVIDERS # Backward compatibility: if no detected_providers, use original discovery logic @@ -64,6 +74,11 @@ class ProviderManager: for provider_name, provider_class in AVAILABLE_PROVIDERS.items(): if provider_name not in self.providers: + # CHECK ENABLED STATUS + if not self._is_provider_enabled(provider_name): + logger.debug(f"ProviderManager: Provider '{provider_name}' is disabled, skipping") + continue + try: provider = provider_class(country=country) self.register_provider(provider) @@ -90,21 +105,36 @@ class ProviderManager: try: if countries: # Multi-country provider + enabled_countries = [] for country_code in countries: + # CHECK COUNTRY-SPECIFIC ENABLED STATUS + if not self._is_provider_enabled(provider_name, country_code): + logger.debug( + f"ProviderManager: Provider '{provider_name}_{country_code}' is disabled, skipping") + continue + provider_key = f"{provider_name}_{country_code}" if provider_key not in self.providers: provider = provider_class(country=country_code.lower()) self.providers[provider_key] = provider + enabled_countries.append(country_code) logger.debug(f"ProviderManager: Registered {provider_key}") - # Return base provider name once for backward compatibility - if provider_name not in registered: + # Only add to registered list if at least one country is enabled + if enabled_countries and provider_name not in registered: registered.append(provider_name) + else: # Single country provider (fallback to default country) + # CHECK ENABLED STATUS + if not self._is_provider_enabled(provider_name): + logger.debug(f"ProviderManager: Provider '{provider_name}' is disabled, skipping") + continue + if provider_name not in self.providers: provider = provider_class(country=country.lower()) self.providers[provider_name] = provider registered.append(provider_name) + except Exception as e: failed.append((provider_name, str(e))) logger.warning(f"ProviderManager: Could not initialize provider '{provider_name}': {e}") diff --git a/lib/streaming_providers/base/settings/settings_manager.py b/lib/streaming_providers/base/settings/settings_manager.py index 7a04508..da9fce1 100644 --- a/lib/streaming_providers/base/settings/settings_manager.py +++ b/lib/streaming_providers/base/settings/settings_manager.py @@ -496,6 +496,7 @@ class SettingsManager: 'provider_name': provider_name, 'country': country, 'is_registered': False, + 'is_enabled': self.is_provider_enabled(provider_name, country), 'error': 'Provider not registered' } @@ -518,6 +519,7 @@ class SettingsManager: 'provider_name': provider_name, 'country': country, 'is_registered': True, + 'is_enabled': self.is_provider_enabled(provider_name, country), 'registered_at': registration.registered_at, 'supports_countries': registration.supports_countries, 'credentials': { @@ -1316,6 +1318,44 @@ class SettingsManager: return status + def is_provider_enabled(self, provider_name: str, country: Optional[str] = None) -> bool: + """ + Check if a provider is enabled via Kodi settings. + + Args: + provider_name: Name of the provider (e.g., 'joyn', 'magenta2') + country: Optional country code (e.g., 'de', 'at') + + Returns: + True if provider is enabled, False if disabled, True by default if no setting found + """ + if not self.kodi_bridge or not self.kodi_bridge.is_kodi_environment(): + return True # Default to enabled if not in Kodi environment + + try: + # Priority 1: Check provider_country specific enable setting (e.g., enable_joyn_de) + if country: + enable_setting_country = f"enable_{provider_name}_{country}" + if self.kodi_bridge.addon.getSetting(enable_setting_country): + enabled = self.kodi_bridge.addon.getSetting(enable_setting_country) + logger.debug(f"Found country-specific enable setting '{enable_setting_country}': {enabled}") + return enabled.lower() in ['true', '1', 'yes'] + + # Priority 2: Check general provider enable setting (e.g., enable_joyn) + enable_setting_general = f"enable_{provider_name}" + if self.kodi_bridge.addon.getSetting(enable_setting_general): + enabled = self.kodi_bridge.addon.getSetting(enable_setting_general) + logger.debug(f"Found general enable setting '{enable_setting_general}': {enabled}") + return enabled.lower() in ['true', '1', 'yes'] + + # No enable setting found - default to enabled + logger.debug(f"No enable setting found for '{provider_name}', defaulting to enabled") + return True + + except Exception as e: + logger.warning(f"Error checking enable status for '{provider_name}': {e}, defaulting to enabled") + return True + # For imports that expect the old interface UnifiedSettingsManager = SettingsManager # Backward compatibility alias