Obey provider enabled setting

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}")

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