Method initialize

src-tauri/src/providers/spotify.rs:373–423

(&self)

impl GenericProvider for SpotifyProvider {
    #[tracing::instrument(level = "debug", skip(self))]
    async fn initialize(&self) -> Result<()> {
        let _ = self
            .status_tx
            .lock()
            .await
            .send(self.get_provider_status(None).await)
            .await;

        let preferences: State<PreferenceConfig> = self.app.state();
        let spotify_config: Value = preferences
            .load_selective("spotify".into())
            .unwrap_or_default();
        let client_id = spotify_config.get("client_id");
        let client_secret = spotify_config.get("client_secret");

        {
            let mut config = self.config.lock().await;
            *config = SpotifyConfig {
                client_id: client_id.map(|v| v.as_str().unwrap().to_string()),
                client_secret: client_secret.map(|v| v.as_str().unwrap().to_string()),
                ..Default::default()
            };

            if config.client_id.as_ref().map_or(true, |id| id.is_empty())
                || config
                    .client_secret
                    .as_ref()
                    .map_or(true, |secret| secret.is_empty())
            {
                config.redirect_uri = "http://127.0.0.1:8898/login";
                config.client_id = Some("65b708073fc0480ea92a077233ca87bd".into())
            } else {
                config.redirect_uri = "https://moosync.app/spotify";
            }
            config.scopes = vec![
                "playlist-read-private",
                "user-top-read",
                "user-library-read",
                "user-read-private",
                "streaming",
                "app-remote-control",
            ];
        }

        let res = self.refresh_login().await;
        if let Err(err) = res {
            tracing::error!("spotify refresh login err: {:?}", err);
        }

        Ok(())
    }

    #[tracing::instrument(level = "debug", skip(self))]
    async fn get_provider_scopes(&self) -> Result<Vec<ExtensionProviderScope>> {