mockspotify 0.0.1

data/src/libmockspotify.h

@@ -0,0 +1,168 @@
+/*
+ * API for libmockspotify
+ *
+ */
+
+
+#ifndef LIBMOCKSPOTIFY_API_H
+#define LIBMOCKSPOTIFY_API_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <libspotify/api.h>
+#include "util.h"
+
+/*** Mock structures ***/
+
+struct sp_session {
+  char username[1024];
+  sp_session_config config;
+  void *userdata;
+  sp_connectionstate connectionstate;
+};
+
+struct sp_album {
+    char name[1024];
+    sp_artist *artist;
+    int year;
+    byte cover[20];
+    int type;
+    int loaded;
+    bool available;
+};
+
+struct sp_albumbrowse {
+    sp_album *album;
+    int loaded;
+};
+
+struct sp_artist {
+    char name[1024];
+    int loaded;
+};
+
+struct sp_artistbrowse {
+    sp_artist *artist;
+    int loaded;
+};
+
+struct sp_image {
+    byte image_id[20];
+    sp_imageformat format;
+    size_t data_size;
+    byte *data;
+    sp_error error;
+};
+
+struct sp_playlist {
+    char name[1024];
+    sp_track *track[32];
+    int num_tracks;
+    sp_playlist_callbacks *callbacks;
+    void *userdata;
+};
+
+struct sp_search {
+    int loaded;
+    int total_tracks;
+    int num_tracks;
+    int num_artists;
+    int num_albums;
+    sp_track *track[20];
+    sp_album *album[20];
+    sp_artist *artist[20];
+    char *query;
+    char *did_you_mean;
+    int error;
+};
+
+struct sp_track {
+    char name[1024];
+    int num_artists;
+    sp_artist *artists[16];
+    sp_album *album;
+    int duration;
+    int popularity;
+    int disc;
+    int index;
+    sp_error error;
+    int loaded;
+    int starred;
+};
+
+struct sp_user {
+    bool loaded;
+    char *canonical_name;
+    char *display_name;
+    char *full_name;
+    char *picture;
+    sp_relation_type relation;
+};
+
+struct sp_link {
+    char data[1024];
+};
+
+/*** Mock events ***/
+
+typedef enum event_type {
+    // SESSION EVENTS
+    MOCK_LOGGED_IN = 0,
+    MOCK_LOGGED_OUT = 1,
+    MOCK_METADATA_UPDATED = 2,
+    MOCK_CONNECTION_ERROR = 3,
+
+    // PLAYLIST EVENTS
+    MOCK_PLAYLIST_TRACKS_ADDED = 20,
+    MOCK_PLAYLIST_TRACKS_MOVED = 21,
+    MOCK_PLAYLIST_TRACKS_REMOVED = 22,
+    MOCK_PLAYLIST_RENAMED = 23,
+    MOCK_PLAYLIST_STATE_CHANGED = 24,
+    MOCK_PLAYLIST_UPDATE_IN_PROGRESS = 25,
+    MOCK_PLAYLIST_METADATA_UPDATED = 26,
+    MOCK_PLAYLIST_TRACK_CREATED_CHANGED = 27,
+    MOCK_PLAYLIST_TRACK_MESSAGE_CHANGED = 28,
+    MOCK_PLAYLIST_TRACK_SEEN_CHANGED = 29,
+    MOCK_PLAYLIST_DESCRIPTION_CHANGED = 30,
+    MOCK_PLAYLIST_SUBSCRIBERS_CHANGED = 31,
+    MOCK_PLAYLIST_IMAGE_CHANGED = 32,
+
+    // CONTAINER EVENTS
+    MOCK_CONTAINER_LOADED = 40,
+    MOCK_CONTAINER_PLAYLIST_ADDED = 41,
+    MOCK_CONTAINER_PLAYLIST_MOVED = 42,
+    MOCK_CONTAINER_PLAYLIST_REMOVED = 43
+} event_type;
+
+void
+mocksp_playlist_event(event_type event, sp_playlist *p);
+
+/*** Mock object creation ***/
+
+sp_album *
+mocksp_album_create(char *name, sp_artist *artist, int year, byte *cover,
+                    int type, int loaded, int available);
+
+sp_albumbrowse *
+mocksp_albumbrowse_create(sp_album *album, bool loaded);
+
+sp_artist *
+mocksp_artist_create(const char *name, int loaded);
+
+sp_artistbrowse *
+mocksp_artistbrowse_create(sp_artist *artist, bool loaded);
+
+sp_playlist *
+mocksp_playlist_create(char *name);
+
+sp_track *
+mocksp_track_create(char *name, int num_artists, sp_artist ** artists,
+                    sp_album * album, int duration, int popularity,
+                    int disc, int index, sp_error error, int loaded);
+
+sp_user *
+mocksp_user_create(char *canonical_name, char *display_name, char *full_name,
+                   char *picture, sp_relation_type relation, bool loaded);
+
+#endif /* LIBMOCKSPOTIFY_API_H */

data/src/link.c

@@ -0,0 +1,77 @@
+#include <string.h>
+#include "libmockspotify.h"
+
+/*** Spotify API ***/
+void
+sp_link_add_ref(sp_link * link)
+{
+}
+
+void
+sp_link_release(sp_link * link)
+{
+}
+
+sp_link *
+sp_link_create_from_string(const char *link)
+{
+  /* unless the link starts with spotify: it is invalid */
+  if ( ! STARTS_WITH(link, "spotify:"))
+  {
+    return NULL;
+  }
+
+  sp_link *lnk = ALLOC(sp_link);
+  snprintf(lnk->data, 1024 /* max size of data in sp_link */, "%s", link);
+  return lnk;
+}
+
+sp_link *
+sp_link_create_from_user(sp_user *user)
+{
+  char *link = ALLOC_N(char, 1024);
+  snprintf(link, "spotify:user:%s", user->canonical_name);
+  return sp_link_create_from_string(link);
+}
+
+int
+sp_link_as_string(sp_link *link, char *buffer, int buffer_size)
+{
+  strncpy(buffer, link->data, buffer_size);
+
+  if (buffer_size > 0)
+  {
+    buffer[buffer_size - 1] = '\0';
+  }
+
+  return (int) strlen(link->data);
+}
+
+sp_linktype
+sp_link_type(sp_link *link)
+{
+  #define LINK_IS(type) (strstr(link->data, ":" #type))
+  #define LINK_CASE_FOR(string, type) if (LINK_IS(string)) { return SP_LINKTYPE_##type; }
+
+  LINK_CASE_FOR(search, SEARCH);
+  LINK_CASE_FOR(track,  TRACK);
+  LINK_CASE_FOR(album,  ALBUM);
+  LINK_CASE_FOR(artist, ARTIST);
+  LINK_CASE_FOR(image,  IMAGE);
+
+  // Order of these three is significant
+  LINK_CASE_FOR(playlist, PLAYLIST);
+  LINK_CASE_FOR(starred,  STARRED);
+  LINK_CASE_FOR(user,     PROFILE);
+
+  return SP_LINKTYPE_INVALID;
+}
+
+sp_user *
+sp_link_as_user(sp_link *link)
+{
+  char *username = ALLOC_N(char, 1024);
+  strncpy(username, link->data, 1024);
+  sp_user *user = mocksp_user_create(username, NULL, NULL, NULL, SP_RELATION_TYPE_UNKNOWN, 1);
+  return user;
+}

data/src/playlist.c

@@ -0,0 +1,165 @@
+#include <stdlib.h>
+#include <string.h>
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+
+void
+mocksp_playlist_event(event_type event, sp_playlist *p)
+{
+    sp_artist *artist = mocksp_artist_create("foo_", 1);
+    sp_album *album = mocksp_album_create("bar_", artist, 2011,
+                                  (byte *) "01234567890123456789", 0, 1, 1);
+    sp_user *user = mocksp_user_create("foo", "", "", "", 0, 0);
+    sp_track *tracks[3] = {
+        mocksp_track_create("foo", 1, &artist, album, 0, 0, 0, 0, 0, 1),
+        mocksp_track_create("bar", 1, &artist, album, 0, 0, 0, 0, 0, 1),
+        mocksp_track_create("baz", 1, &artist, album, 0, 0, 0, 0, 0, 1)
+    };
+    int nums[3] = { 0, 1, 2 };
+
+    switch (event) {
+    case MOCK_PLAYLIST_TRACKS_ADDED:
+        if (p->callbacks->tracks_added)
+            p->callbacks->tracks_added(p, tracks, 3, 0, p->userdata);
+        break;
+    case MOCK_PLAYLIST_TRACKS_MOVED:
+        if (p->callbacks->tracks_moved)
+            p->callbacks->tracks_moved(p, nums, 3, 0, p->userdata);
+        break;
+    case MOCK_PLAYLIST_TRACKS_REMOVED:
+        if (p->callbacks->tracks_removed)
+            p->callbacks->tracks_removed(p, nums, 3, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_RENAMED:
+        if (p->callbacks->playlist_renamed)
+            p->callbacks->playlist_renamed(p, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_STATE_CHANGED:
+        if (p->callbacks->playlist_state_changed)
+            p->callbacks->playlist_state_changed(p, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_UPDATE_IN_PROGRESS:
+        if (p->callbacks->playlist_update_in_progress)
+            p->callbacks->playlist_update_in_progress(p, 1, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_METADATA_UPDATED:
+        if (p->callbacks->playlist_metadata_updated)
+            p->callbacks->playlist_metadata_updated(p, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_TRACK_CREATED_CHANGED:
+        if (p->callbacks->track_created_changed)
+            p->callbacks->track_created_changed(p, 1, user, 123, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_TRACK_MESSAGE_CHANGED:
+        if (p->callbacks->track_message_changed)
+            p->callbacks->track_message_changed(p, 1, "foo", p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_TRACK_SEEN_CHANGED:
+        if (p->callbacks->track_seen_changed)
+            p->callbacks->track_seen_changed(p, 1, 0, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_DESCRIPTION_CHANGED:
+        if (p->callbacks->description_changed)
+            p->callbacks->description_changed(p, "foo", p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_SUBSCRIBERS_CHANGED:
+        if (p->callbacks->subscribers_changed)
+            p->callbacks->subscribers_changed(p, p->userdata);
+        break;
+
+    case MOCK_PLAYLIST_IMAGE_CHANGED:
+        if (p->callbacks->image_changed)
+            p->callbacks->image_changed(p, (byte *) "01234567890123456789",
+                                        p->userdata);
+        break;
+
+    default:
+        break;
+    }
+}
+
+/*** Spotify API ***/
+
+void
+sp_playlist_add_ref(sp_playlist *p)
+{
+}
+
+void
+sp_playlist_release(sp_playlist *p)
+{
+}
+
+void
+sp_playlist_set_autolink_tracks(sp_playlist *p, bool set)
+{
+}
+
+bool
+sp_playlist_is_loaded(sp_playlist *p)
+{
+    return 1;
+}
+
+const char *
+sp_playlist_name(sp_playlist *p)
+{
+    return p->name;
+}
+
+sp_error
+sp_playlist_rename(sp_playlist *p, const char *new_name)
+{
+    strcpy(p->name, new_name);
+    return SP_ERROR_OK;
+}
+
+sp_track *
+sp_playlist_track(sp_playlist *p, int index)
+{
+    return p->track[index];
+}
+
+int
+sp_playlist_num_tracks(sp_playlist *p)
+{
+    return p->num_tracks;
+}
+
+void
+sp_playlist_add_callbacks(sp_playlist *p, sp_playlist_callbacks *cb,
+                          void *userdata)
+{
+    p->callbacks = cb;
+    p->userdata = userdata;
+}
+
+void
+sp_playlist_remove_callbacks(sp_playlist *p, sp_playlist_callbacks *cb,
+                             void *userdata)
+{
+    p->callbacks = NULL;
+}
+
+bool
+sp_playlist_is_collaborative(sp_playlist *p)
+{
+    return 0;
+}
+
+sp_error
+sp_playlist_remove_tracks(sp_playlist *p, const int *tracks, int num_tracks)
+{
+    // TODO
+    return SP_ERROR_OK;
+}

data/src/search.c

@@ -0,0 +1,128 @@
+#include <stdlib.h>
+#include <string.h>
+#include "libmockspotify.h"
+
+/*** Spotify API ***/
+
+void
+sp_search_add_ref(sp_search *search)
+{
+}
+
+void
+sp_search_release(sp_search *search)
+{
+}
+
+sp_search *
+sp_search_create(sp_session *session, const char *query, int track_offset,
+                 int track_count, int album_offset, int album_count,
+                 int artist_offset, int artist_count,
+                 search_complete_cb *callback, void *userdata)
+{
+    sp_search *search = malloc(sizeof(sp_search));
+
+    if (!strncmp(query, "!loaded", 7))
+        search->loaded = 0;
+    if (!strncmp(query, "loaded", 6))
+        search->loaded = 1;
+    search->num_tracks = 4;
+    search->num_albums = 3;
+    search->num_artists = 2;
+    search->total_tracks = 24;
+    search->query = malloc(strlen(query) + 1);
+    strcpy(search->query, query);
+    search->error = 3;
+    search->did_you_mean = "did_you_mean";
+    search->artist[0] = mocksp_artist_create("foo", 1);
+    search->artist[1] = mocksp_artist_create("bar", 1);
+    search->album[0] = mocksp_album_create("baz", search->artist[0], 2001,
+                                           (byte *) "01234567890123456789",
+                                           1, 1, 1);
+    search->album[1] = mocksp_album_create("qux", search->artist[1], 2002,
+                                           (byte *) "01234567890123456789",
+                                           1, 1, 1);
+    search->album[2] = mocksp_album_create("quux", search->artist[0], 2003,
+                                           (byte *) "01234567890123456789",
+                                           1, 1, 1);
+    search->track[0] =
+        mocksp_track_create("corge", 1, search->artist, search->album[0],
+                            99, 72, 1, 1, 0, 1);
+    search->track[1] =
+        mocksp_track_create("grault", 1, search->artist, search->album[1],
+                            98, 72, 1, 1, 0, 1);
+    search->track[2] =
+        mocksp_track_create("garply", 1, search->artist, search->album[2],
+                            97, 72, 1, 1, 0, 1);
+    search->track[3] =
+        mocksp_track_create("waldo", 1, search->artist, search->album[0],
+                            96, 72, 1, 1, 0, 1);
+    callback(search, userdata);
+    return search;
+}
+
+bool
+sp_search_is_loaded(sp_search *s)
+{
+    return s->loaded;
+}
+
+int
+sp_search_num_artists(sp_search *s)
+{
+    return s->num_artists;
+}
+
+int
+sp_search_num_albums(sp_search *s)
+{
+    return s->num_albums;
+}
+
+int
+sp_search_num_tracks(sp_search *s)
+{
+    return s->num_tracks;
+}
+
+int
+sp_search_total_tracks(sp_search *s)
+{
+    return s->total_tracks;
+}
+
+sp_artist *
+sp_search_artist(sp_search *s, int i)
+{
+    return s->artist[i];
+}
+
+sp_album *
+sp_search_album(sp_search *s, int i)
+{
+    return s->album[i];
+}
+
+sp_track *
+sp_search_track(sp_search *s, int i)
+{
+    return s->track[i];
+}
+
+const char *
+sp_search_query(sp_search *s)
+{
+    return s->query;
+}
+
+sp_error
+sp_search_error(sp_search *s)
+{
+    return s->error;
+}
+
+const char *
+sp_search_did_you_mean(sp_search *s)
+{
+    return s->did_you_mean;
+}

data/src/session.c

@@ -0,0 +1,73 @@
+#include "libmockspotify.h"
+
+/*** Spotify API ***/
+
+sp_error
+sp_session_create(const sp_session_config * config, sp_session ** sess)
+{
+    if (memcmp(config->application_key, "appkey_good", config->application_key_size))
+        return SP_ERROR_BAD_APPLICATION_KEY;
+
+    *sess = ALLOC(sp_session);
+    sp_session *session = *sess;
+
+    session->config.cache_location    = malloc(strlen(config->cache_location) + 1);
+    session->config.settings_location = malloc(strlen(config->settings_location) + 1);
+    session->config.application_key   = malloc(config->application_key_size);
+    session->config.user_agent        = malloc(strlen(config->user_agent) + 1);
+    session->config.callbacks         = ALLOC(sp_session_callbacks);
+    session->config.userdata          = config->userdata;
+
+    session->config.api_version       = config->api_version;
+    strcpy((char *)session->config.cache_location, config->cache_location);
+    strcpy((char *)session->config.settings_location, config->settings_location);
+    memcpy((char *)session->config.application_key, config->application_key, config->application_key_size);
+    strcpy((char *)session->config.user_agent, config->user_agent);
+    memcpy((char *)session->config.callbacks, config->callbacks, sizeof(sp_session_callbacks));
+    session->config.userdata          = config->userdata;
+
+    // TODO: v0.0.8 (and earlier) directly call `notify_main_thread` callback here, before returning
+    if (config->callbacks->notify_main_thread)
+      config->callbacks->notify_main_thread(NULL);
+
+    return SP_ERROR_OK;
+}
+
+void
+sp_session_process_events(sp_session *session, int *next_timeout)
+{
+    *next_timeout = 60000;
+}
+
+sp_connectionstate
+sp_session_connectionstate(sp_session *session)
+{
+    return session->connectionstate;
+}
+
+void *
+sp_session_userdata(sp_session *session)
+{
+    return session->config.userdata;
+}
+
+void
+sp_session_login(sp_session *session, const char *username, const char *password)
+{
+    session->connectionstate = SP_CONNECTION_STATE_LOGGED_IN;
+}
+
+void
+sp_session_logout(sp_session *session)
+{
+  session->connectionstate = SP_CONNECTION_STATE_LOGGED_OUT;
+}
+
+sp_user *
+sp_session_user(sp_session *session)
+{
+  char *username = ALLOC_N(char, 1024);
+  strncpy(username, session->username, 1024);
+  sp_user *user = mocksp_user_create(username, NULL, NULL, NULL, SP_RELATION_TYPE_NONE, 1);
+  return user;
+}