Method create_api_client

src-tauri/src/providers/spotify.rs:148–192

(&self)

    #[tracing::instrument(level = "debug", skip(self))]
    async fn create_api_client(&self) {
        tracing::debug!("Creating spotify api client");
        if let Some(token) = self.tokens.lock().await.as_ref() {
            tracing::debug!("Got tokens lock");
            *self.api_client.write().await = Some(ApiClient {
                api_client: AuthCodePkceSpotify::from_token(Token {
                    access_token: token.access_token.clone(),
                    expires_in: TimeDelta::seconds(token.expires_in.try_into().unwrap()),
                    expires_at: Some(DateTime::from_timestamp_millis(token.expires_at).unwrap()),
                    refresh_token: Some(token.refresh_token.clone()),
                    scopes: HashSet::from_iter(
                        self.config
                            .lock()
                            .await
                            .scopes
                            .iter()
                            .map(|v| v.to_string()),
                    ),
                }),
                token_expiry: Instant::now() + Duration::from_secs(token.expires_in),
            });

            let res = self.fetch_user_details().await;
            let mut is_spotify_premium = false;
            if let Ok((res, is_premium)) = res {
                let _ = self.status_tx.lock().await.send(res).await;
                is_spotify_premium = is_premium;
            } else {
                let _ = self
                    .status_tx
                    .lock()
                    .await
                    .send(self.get_provider_status(Some("".into())).await)
                    .await;
            }

            if is_spotify_premium {
                tracing::debug!("Initializing librespot");
                if let Err(err) = initialize_librespot(self.app.clone(), token.access_token.clone())
                {
                    tracing::error!("Error initializing librespot {:?}", err);
                }
            }
        }
    }

    async fn get_api_client(&self) -> RwLockReadGuard<'_, Option<ApiClient>> {
        if let Some(expired) = self