[clinton/xbmc-groove.git] / default.py

import urllib, urllib2, re, xbmcplugin, xbmcgui, xbmc, sys, os

# plugin constants
__plugin__ = "Grooveshark"
__author__ = "Stephen Denham"
__url__ = ""
__svn_url__ = ""
__version__ = "0.0.1"
__svn_revision__ = ""
__XBMC_Revision__ = ""

MODE_SEARCH_SONGS = 1
MODE_SEARCH_ALBUMS = 2
MODE_SEARCH_ARTISTS = 3
MODE_POPULAR = 4
MODE_FAVORITES = 5
MODE_PLAYLISTS = 6
MODE_ALBUM = 7
MODE_ARTIST = 8
MODE_PLAYLIST = 9
MODE_SONG = 10
MODE_FAVORITE = 11
MODE_UNFAVORITE = 12

songsearchlimit = 25
albumsearchlimit = 15
artistsearchlimit = 15

lastID = 0

rootDir = os.getcwd()

resDir = xbmc.translatePath(os.path.join(rootDir, 'resources'))
libDir = xbmc.translatePath(os.path.join(resDir,  'lib'))
imgDir = xbmc.translatePath(os.path.join(resDir,  'img'))

sys.path.append (libDir)
from GrooveAPI import *
groovesharkApi = GrooveAPI()

class _Info:
    def __init__( self, *args, **kwargs ):
        self.__dict__.update( kwargs )

class Groveshark:

    albumImg = xbmc.translatePath(os.path.join(imgDir,  'album.png'))
    artistImg = xbmc.translatePath(os.path.join(imgDir,  'artist.png'))
    favoritesImg = xbmc.translatePath(os.path.join(imgDir,  'favorites.png'))
    playlistImg = xbmc.translatePath(os.path.join(imgDir,  'playlist.png'))
    popularImg = xbmc.translatePath(os.path.join(imgDir,  'popular.png'))
    songImg = xbmc.translatePath(os.path.join(imgDir,  'song.png'))

    songsearchlimit = xbmcplugin.getSetting('songsearchlimit')
    albumsearchlimit = xbmcplugin.getSetting('albumsearchlimit')
    artistsearchlimit = xbmcplugin.getSetting('artistsearchlimit')
   
    def __init__( self ):
        self._handle = int(sys.argv[1])
    
    def categories(self):
        userid = self._get_login()
        self._addDir('Search songs', '', MODE_SEARCH_SONGS, self.songImg, 0)
        self._addDir('Search albums', '', MODE_SEARCH_ALBUMS, self.albumImg, 0)
        self._addDir('Search artists', '', MODE_SEARCH_ARTISTS, self.artistImg, 0)
        self._addDir('Popular', '', MODE_POPULAR, self.popularImg, 0)
        if (userid != 0):
            self._addDir('Favorites', '', MODE_FAVORITES, self.favoritesImg, 0)
            self._addDir('Playlists', '', MODE_PLAYLISTS, self.playlistImg, 0)
                           
    def searchSongs(self):
        query = self._get_keyboard(default="", heading="Search songs")
        if (query): 
            songs = groovesharkApi.searchSongs(query, limit = songsearchlimit)
            if (len(songs) > 0):
                self._get_songs(songs)
            else:
                dialog = xbmcgui.Dialog()
                dialog.ok('Grooveshark', 'No matching songs.')
                self.categories()
    
    def searchAlbums(self):
        query = self._get_keyboard(default="", heading="Search albums")
        if (query): 
            albums = groovesharkApi.searchAlbums(query, limit = albumsearchlimit)
            if (len(albums) > 0):
                self._get_albums(albums)
            else:
                dialog = xbmcgui.Dialog()
                dialog.ok('Grooveshark', 'No matching albums.')
                self.categories()
    
    def searchArtists(self):
        query = self._get_keyboard(default="", heading="Search artists")
        if (query): 
            artists = groovesharkApi.searchArtists(query, limit = artistsearchlimit)
            if (len(artists) > 0):
                self._get_artists(artists)
            else:
                dialog = xbmcgui.Dialog()
                dialog.ok('Grooveshark', 'No matching artists.')
                self.categories()
                    
    def favorites(self):
        userid = self._get_login()
        if (userid != 0):
            favorites = groovesharkApi.userGetFavoriteSongs(userid)
            if (len(favorites) > 0):
                self._get_songs(favorites)
            else:
                dialog = xbmcgui.Dialog()
                dialog.ok('Grooveshark', 'You have no favorites.')
                self.categories()
    
    def popular(self):
        popular = groovesharkApi.popularGetSongs(limit = songsearchlimit)
        if (len(popular) > 0):
            self._get_songs(popular)
        else:
            dialog = xbmcgui.Dialog()
            dialog.ok('Grooveshark', 'No popular songs.')
            self.categories()
                 
    def playlists(self):
        userid = self._get_login()
        if (userid != 0):
            playlists = groovesharkApi.userGetPlaylists()
            if (len(playlists) > 0):
                self._get_playlists(playlists)
            else:
                dialog = xbmcgui.Dialog()
                dialog.ok('Grooveshark', 'You have no playlists.')
                self.categories()
                
    def favorite(self, songid):
        userid = self._get_login()
        if (userid != 0):
            xbmc.log("Favorite song: " + str(songid))
            groovesharkApi.favoriteSong(songID = songid)
        else:
            dialog = xbmcgui.Dialog()
            dialog.ok('Grooveshark', 'You must be logged in', 'to add favorites.')
    
    def unfavorite(self, songid):
        userid = self._get_login()
        if (userid != 0):
            xbmc.log("Unfavorite song: " + str(songid))
            groovesharkApi.unfavoriteSong(songID = songid)
        else:
            dialog = xbmcgui.Dialog()
            dialog.ok('Grooveshark', 'You must be logged in', 'to remove favorites.')
    
    def album(self,albumid):
        album = groovesharkApi.albumGetSongs(albumId = albumid, limit = songsearchlimit)
        self._get_songs(album)
    
    def artist(self, artistid):
        albums = groovesharkApi.artistGetAlbums(artistId = artistid, limit = albumsearchlimit)
        self._get_albums(albums)
    
    def playlist(self, playlistid):
        userid = self._get_login()
        if (userid != 0):
            songs = groovesharkApi.playlistGetSongs(playlistId = playlistid, limit = songsearchlimit)
            self._get_songs(songs)
        else:
            dialog = xbmcgui.Dialog()
            dialog.ok('Grooveshark', 'You must be logged in', 'to get playlists.')
            
    def song(self, url, name, album, artist, duration):
        xbmc.log("Playing: " + url)
        songItem = xbmcgui.ListItem(name + " - " + artist, path=url)
        songItem.setInfo( type="Music", infoLabels={ "Title": name, "Duration": duration, "Album": album, "Artist": artist} )
        xbmc.Player().stop()
        xbmc.Player(xbmc.PLAYER_CORE_PAPLAYER).play(url, songItem, False)
        
    def _get_keyboard(self, default="", heading="", hidden=False):
            kb = xbmc.Keyboard(default, heading, hidden)
            kb.doModal()
            if (kb.isConfirmed()):
                return unicode(kb.getText(), "utf-8")
            return ''
    
    def _get_login(self):
        username = xbmcplugin.getSetting('username')
        password = xbmcplugin.getSetting('password')
        if (username == "" or password == ""):
            dialog = xbmcgui.Dialog()
            dialog.ok('Grooveshark', 'Unable to login.', 'Check username and password in settings.')
            return 0
        else:
            if groovesharkApi.loggedInStatus() == 1:
                groovesharkApi.logout()
            try:    
                userid = groovesharkApi.loginExt(username, password)
            except (LoginUnknownError):
                userid = 0
            if (userid != 0):
                xbmc.log("Logged in")
                return userid
            else:
                dialog = xbmcgui.Dialog()
                dialog.ok('Grooveshark', 'Unable to login.', 'Check username and password in settings.')
                return 0
    
    def _get_songs(self, songs):
        xbmc.log("Found " + str(len(songs)) + " songs...")
        i = 0
        while i < len(songs):
            song = songs[i]
            songName = song[0]
            songID = song[1]
            songDuration = song[2]
            songAlbum = song[3]
            songArtist = song[6]
            songImage = song[9]
            xbmc.log(songName)
            self._addSong(songID, songName, groovesharkApi.getStreamURL(songID), songDuration, songAlbum, songArtist, songImage)
            i = i + 1
        xbmcplugin.setContent(self._handle, 'songs')
        xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_TITLE_IGNORE_THE)
            
    def _get_albums(self, albums):
        xbmc.log("Found " + str(len(albums)) + " albums...")
        i = 0
        while i < len(albums):
            album = albums[i]
            albumArtistName = album[0]
            albumName = album[2]
            albumID = album[3]
            albumImage = album[4]
            xbmc.log(albumName)
            self._addDir(albumName + " - " + albumArtistName, '', MODE_ALBUM, albumImage, albumID)
            i = i + 1
        xbmcplugin.setContent(self._handle, 'albums')
        xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_ALBUM_IGNORE_THE)
            
    def _get_artists(self, artists):
        xbmc.log("Found " + str(len(artists)) + " artists...")
        i = 0
        while i < len(artists):
            artist = artists[i]
            artistName = artist[0]
            artistID = artist[1]
            xbmc.log(artistName)
            self._addDir(artistName, '', MODE_ARTIST, self.artistImg, artistID)
            i = i + 1
        xbmcplugin.setContent(self._handle, 'artists')
        xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_ARTIST_IGNORE_THE)
            
    def _get_playlists(self, playlists):
        xbmc.log("Found " + str(len(playlists)) + " playlists...")
        i = 0
        while i < len(playlists):
            playlist = playlists[i]
            playlistName = playlist[0]
            playlistID = playlist[1]
            xbmc.log(playlistName)
            self._addDir(playlistName, '', MODE_PLAYLIST, self.playlistImg, playlistID, )
            i = i + 1  
        xbmcplugin.setContent(self._handle, 'files')
        xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_PLAYLIST_ORDER)
        
    def _addSong(self, songid, songname, songurl, songduration, songalbum, songartist, songimage):
        u=sys.argv[0]+"?url="+urllib.quote_plus(songurl)+"&mode="+str(MODE_SONG)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid) \
        +"&album="+urllib.quote_plus(songalbum) \
        +"&artist="+urllib.quote_plus(songartist) \
        +"&duration="+str(songduration)
        songItem = xbmcgui.ListItem(songname + " - " + songartist, iconImage=songimage, thumbnailImage=songimage, path=songurl)
        songItem.setInfo( type="Music", infoLabels={ "Title": songname, "Duration": songduration, "Album": songalbum, "Artist": songartist} )
        fav=sys.argv[0]+"?url="+urllib.quote_plus(songurl)+"&mode="+str(MODE_FAVORITE)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid)
        unfav=sys.argv[0]+"?url="+urllib.quote_plus(songurl)+"&mode="+str(MODE_UNFAVORITE)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid)
        menuItems = []
        menuItems.append(("Grooveshark Favorite",      "XBMC.RunPlugin("+fav+")"))
        menuItems.append(("Not Grooveshark Favorite", "XBMC.RunPlugin("+unfav+")"))
        songItem.addContextMenuItems(menuItems, replaceItems=False)
        return xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=songItem,isFolder=False)
      
    def _addDir(self, name, url, mode, iconimage, id):
        u=sys.argv[0]+"?url="+urllib.quote_plus(url)+"&mode="+str(mode)+"&name="+urllib.quote_plus(name)+"&id="+str(id)
        dir=xbmcgui.ListItem(name, iconImage=iconimage, thumbnailImage=iconimage)
        dir.setInfo( type="Music", infoLabels={ "Title": name } )
        # Codes from http://xbmc-scripting.googlecode.com/svn/trunk/Script%20Templates/common/gui/codes.py
        menuItems = []
        menuItems.append(("Select", "XBMC.executebuiltin(Action(7))"))
        dir.addContextMenuItems(menuItems, replaceItems=True)
        return xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=dir,isFolder=True)
   
def get_params():
    param=[]
    paramstring=sys.argv[2]
    if len(paramstring)>=2:
        params=sys.argv[2]
        cleanedparams=params.replace('?','')
        if (params[len(params)-1]=='/'):
            params=params[0:len(params)-2]
        pairsofparams=cleanedparams.split('&')
        param={}
        for i in range(len(pairsofparams)):
            splitparams={}
            splitparams=pairsofparams[i].split('=')
            if (len(splitparams))==2:
                param[splitparams[0]]=splitparams[1]
    print param              
    return param
        
grooveshark = Groveshark();
    
params=get_params()
url=None
name=None
mode=None
id=None

try: url=urllib.unquote_plus(params["url"]) 
except: pass
try: name=urllib.unquote_plus(params["name"])
except: pass
try: mode=int(params["mode"])
except: pass
try: id=int(params["id"])
except: pass

if (id > 0):
    lastID = id

if mode==None:
    grooveshark.categories()
       
elif mode==MODE_SEARCH_SONGS:
    grooveshark.searchSongs()
    
elif mode==MODE_SEARCH_ALBUMS:
    grooveshark.searchAlbums()

elif mode==MODE_SEARCH_ARTISTS:
    grooveshark.searchArtists()

elif mode==MODE_POPULAR:
    grooveshark.popular()

elif mode==MODE_PLAYLISTS:
    grooveshark.playlists()

elif mode==MODE_FAVORITES:
    grooveshark.favorites()

elif mode==MODE_SONG:
    try: name=urllib.unquote_plus(params["name"])
    except: pass
    try: album=urllib.unquote_plus(params["album"])
    except: pass
    try: artist=urllib.unquote_plus(params["artist"])
    except: pass
    try: duration=int(params["duration"])
    except: pass
    grooveshark.song(url, name, album, artist, duration)

elif mode==MODE_ARTIST:
    grooveshark.artist(lastID)
    
elif mode==MODE_ALBUM:
    grooveshark.album(lastID)
    
elif mode==MODE_PLAYLIST:
    grooveshark.playlist(lastID)
    
elif mode==MODE_FAVORITE:
    grooveshark.favorite(lastID)

elif mode==MODE_UNFAVORITE:
    grooveshark.unfavorite(lastID)
    
if (mode < MODE_SONG):    
    xbmcplugin.endOfDirectory(int(sys.argv[1]))
Commit	Line	Data
8817bb2e	1	import urllib, urllib2, re, xbmcplugin, xbmcgui, xbmc, sys, os
	2
	3	# plugin constants
	4	__plugin__ = "Grooveshark"
	5	__author__ = "Stephen Denham"
	6	__url__ = ""
	7	__svn_url__ = ""
	8	__version__ = "0.0.1"
	9	__svn_revision__ = ""
	10	__XBMC_Revision__ = ""
	11
	12	MODE_SEARCH_SONGS = 1
	13	MODE_SEARCH_ALBUMS = 2
	14	MODE_SEARCH_ARTISTS = 3
	15	MODE_POPULAR = 4
	16	MODE_FAVORITES = 5
	17	MODE_PLAYLISTS = 6
	18	MODE_ALBUM = 7
	19	MODE_ARTIST = 8
	20	MODE_PLAYLIST = 9
	21	MODE_SONG = 10
	22	MODE_FAVORITE = 11
	23	MODE_UNFAVORITE = 12
	24
	25	songsearchlimit = 25
	26	albumsearchlimit = 15
	27	artistsearchlimit = 15
	28
	29	lastID = 0
	30
	31	rootDir = os.getcwd()
	32
	33	resDir = xbmc.translatePath(os.path.join(rootDir, 'resources'))
	34	libDir = xbmc.translatePath(os.path.join(resDir, 'lib'))
	35	imgDir = xbmc.translatePath(os.path.join(resDir, 'img'))
	36
	37	sys.path.append (libDir)
	38	from GrooveAPI import *
	39	groovesharkApi = GrooveAPI()
	40
	41	class _Info:
	42	def __init__( self, args, *kwargs ):
	43	self.__dict__.update( kwargs )
	44
	45	class Groveshark:
	46
	47	albumImg = xbmc.translatePath(os.path.join(imgDir, 'album.png'))
	48	artistImg = xbmc.translatePath(os.path.join(imgDir, 'artist.png'))
	49	favoritesImg = xbmc.translatePath(os.path.join(imgDir, 'favorites.png'))
	50	playlistImg = xbmc.translatePath(os.path.join(imgDir, 'playlist.png'))
	51	popularImg = xbmc.translatePath(os.path.join(imgDir, 'popular.png'))
	52	songImg = xbmc.translatePath(os.path.join(imgDir, 'song.png'))
	53
	54	songsearchlimit = xbmcplugin.getSetting('songsearchlimit')
	55	albumsearchlimit = xbmcplugin.getSetting('albumsearchlimit')
	56	artistsearchlimit = xbmcplugin.getSetting('artistsearchlimit')
	57
	58	def __init__( self ):
	59	self._handle = int(sys.argv[1])
	60
	61	def categories(self):
	62	userid = self._get_login()
	63	self._addDir('Search songs', '', MODE_SEARCH_SONGS, self.songImg, 0)
	64	self._addDir('Search albums', '', MODE_SEARCH_ALBUMS, self.albumImg, 0)
65	self._addDir('Search artists', '', MODE_SEARCH_ARTISTS, self.artistImg, 0)
66	self._addDir('Popular', '', MODE_POPULAR, self.popularImg, 0)
67	if (userid != 0):
68	self._addDir('Favorites', '', MODE_FAVORITES, self.favoritesImg, 0)
69	self._addDir('Playlists', '', MODE_PLAYLISTS, self.playlistImg, 0)
70
71	def searchSongs(self):
72	query = self._get_keyboard(default="", heading="Search songs")
73	if (query):
74	songs = groovesharkApi.searchSongs(query, limit = songsearchlimit)
75	if (len(songs) > 0):
76	self._get_songs(songs)
77	else:
78	dialog = xbmcgui.Dialog()
79	dialog.ok('Grooveshark', 'No matching songs.')
80	self.categories()
81
82	def searchAlbums(self):
83	query = self._get_keyboard(default="", heading="Search albums")
84	if (query):
85	albums = groovesharkApi.searchAlbums(query, limit = albumsearchlimit)
86	if (len(albums) > 0):
87	self._get_albums(albums)
88	else:
89	dialog = xbmcgui.Dialog()
90	dialog.ok('Grooveshark', 'No matching albums.')
91	self.categories()
92
93	def searchArtists(self):
94	query = self._get_keyboard(default="", heading="Search artists")
95	if (query):
96	artists = groovesharkApi.searchArtists(query, limit = artistsearchlimit)
97	if (len(artists) > 0):
98	self._get_artists(artists)
99	else:
100	dialog = xbmcgui.Dialog()
101	dialog.ok('Grooveshark', 'No matching artists.')
102	self.categories()
103
104	def favorites(self):
105	userid = self._get_login()
106	if (userid != 0):
107	favorites = groovesharkApi.userGetFavoriteSongs(userid)
108	if (len(favorites) > 0):
109	self._get_songs(favorites)
110	else:
111	dialog = xbmcgui.Dialog()
112	dialog.ok('Grooveshark', 'You have no favorites.')
113	self.categories()
114
115	def popular(self):
116	popular = groovesharkApi.popularGetSongs(limit = songsearchlimit)
117	if (len(popular) > 0):
118	self._get_songs(popular)
119	else:
120	dialog = xbmcgui.Dialog()
121	dialog.ok('Grooveshark', 'No popular songs.')
122	self.categories()
123
124	def playlists(self):
125	userid = self._get_login()
126	if (userid != 0):
127	playlists = groovesharkApi.userGetPlaylists()
128	if (len(playlists) > 0):
129	self._get_playlists(playlists)
130	else:
131	dialog = xbmcgui.Dialog()
132	dialog.ok('Grooveshark', 'You have no playlists.')
133	self.categories()
134
135	def favorite(self, songid):
136	userid = self._get_login()
137	if (userid != 0):
138	xbmc.log("Favorite song: " + str(songid))
139	groovesharkApi.favoriteSong(songID = songid)
140	else:
141	dialog = xbmcgui.Dialog()
142	dialog.ok('Grooveshark', 'You must be logged in', 'to add favorites.')
143
144	def unfavorite(self, songid):
145	userid = self._get_login()
146	if (userid != 0):
147	xbmc.log("Unfavorite song: " + str(songid))
148	groovesharkApi.unfavoriteSong(songID = songid)
149	else:
150	dialog = xbmcgui.Dialog()
151	dialog.ok('Grooveshark', 'You must be logged in', 'to remove favorites.')
152
153	def album(self,albumid):
154	album = groovesharkApi.albumGetSongs(albumId = albumid, limit = songsearchlimit)
155	self._get_songs(album)
156
157	def artist(self, artistid):
158	albums = groovesharkApi.artistGetAlbums(artistId = artistid, limit = albumsearchlimit)
159	self._get_albums(albums)
160
161	def playlist(self, playlistid):
162	userid = self._get_login()
163	if (userid != 0):
164	songs = groovesharkApi.playlistGetSongs(playlistId = playlistid, limit = songsearchlimit)
165	self._get_songs(songs)
166	else:
167	dialog = xbmcgui.Dialog()
168	dialog.ok('Grooveshark', 'You must be logged in', 'to get playlists.')
169
170	def song(self, url, name, album, artist, duration):
171	xbmc.log("Playing: " + url)
172	songItem = xbmcgui.ListItem(name + " - " + artist, path=url)
173	songItem.setInfo( type="Music", infoLabels={ "Title": name, "Duration": duration, "Album": album, "Artist": artist} )
174	xbmc.Player().stop()
175	xbmc.Player(xbmc.PLAYER_CORE_PAPLAYER).play(url, songItem, False)
176
177	def _get_keyboard(self, default="", heading="", hidden=False):
178	kb = xbmc.Keyboard(default, heading, hidden)
179	kb.doModal()
180	if (kb.isConfirmed()):
181	return unicode(kb.getText(), "utf-8")
182	return ''
183
184	def _get_login(self):
185	username = xbmcplugin.getSetting('username')
186	password = xbmcplugin.getSetting('password')
187	if (username == "" or password == ""):
188	dialog = xbmcgui.Dialog()
189	dialog.ok('Grooveshark', 'Unable to login.', 'Check username and password in settings.')
190	return 0
191	else:
192	if groovesharkApi.loggedInStatus() == 1:
193	groovesharkApi.logout()
194	try:
195	userid = groovesharkApi.loginExt(username, password)
196	except (LoginUnknownError):
197	userid = 0
198	if (userid != 0):
199	xbmc.log("Logged in")
200	return userid
201	else:
202	dialog = xbmcgui.Dialog()
203	dialog.ok('Grooveshark', 'Unable to login.', 'Check username and password in settings.')
204	return 0
205
206	def _get_songs(self, songs):
207	xbmc.log("Found " + str(len(songs)) + " songs...")
208	i = 0
209	while i < len(songs):
210	song = songs[i]
211	songName = song[0]
212	songID = song[1]
213	songDuration = song[2]
214	songAlbum = song[3]
215	songArtist = song[6]
216	songImage = song[9]
217	xbmc.log(songName)
218	self._addSong(songID, songName, groovesharkApi.getStreamURL(songID), songDuration, songAlbum, songArtist, songImage)
219	i = i + 1
220	xbmcplugin.setContent(self._handle, 'songs')
221	xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_TITLE_IGNORE_THE)
222
223	def _get_albums(self, albums):
224	xbmc.log("Found " + str(len(albums)) + " albums...")
225	i = 0
226	while i < len(albums):
227	album = albums[i]
228	albumArtistName = album[0]
229	albumName = album[2]
230	albumID = album[3]
231	albumImage = album[4]
232	xbmc.log(albumName)
233	self._addDir(albumName + " - " + albumArtistName, '', MODE_ALBUM, albumImage, albumID)
234	i = i + 1
235	xbmcplugin.setContent(self._handle, 'albums')
236	xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_ALBUM_IGNORE_THE)
237
238	def _get_artists(self, artists):
239	xbmc.log("Found " + str(len(artists)) + " artists...")
240	i = 0
241	while i < len(artists):
242	artist = artists[i]
243	artistName = artist[0]
244	artistID = artist[1]
245	xbmc.log(artistName)
246	self._addDir(artistName, '', MODE_ARTIST, self.artistImg, artistID)
247	i = i + 1
248	xbmcplugin.setContent(self._handle, 'artists')
249	xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_ARTIST_IGNORE_THE)
250
251	def _get_playlists(self, playlists):
252	xbmc.log("Found " + str(len(playlists)) + " playlists...")
253	i = 0
254	while i < len(playlists):
255	playlist = playlists[i]
256	playlistName = playlist[0]
257	playlistID = playlist[1]
258	xbmc.log(playlistName)
259	self._addDir(playlistName, '', MODE_PLAYLIST, self.playlistImg, playlistID, )
260	i = i + 1
261	xbmcplugin.setContent(self._handle, 'files')
262	xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_PLAYLIST_ORDER)
263
264	def _addSong(self, songid, songname, songurl, songduration, songalbum, songartist, songimage):
265	u=sys.argv[0]+"?url="+urllib.quote_plus(songurl)+"&mode="+str(MODE_SONG)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid) \
266	+"&album="+urllib.quote_plus(songalbum) \
267	+"&artist="+urllib.quote_plus(songartist) \
268	+"&duration="+str(songduration)
269	songItem = xbmcgui.ListItem(songname + " - " + songartist, iconImage=songimage, thumbnailImage=songimage, path=songurl)
270	songItem.setInfo( type="Music", infoLabels={ "Title": songname, "Duration": songduration, "Album": songalbum, "Artist": songartist} )
271	fav=sys.argv[0]+"?url="+urllib.quote_plus(songurl)+"&mode="+str(MODE_FAVORITE)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid)
272	unfav=sys.argv[0]+"?url="+urllib.quote_plus(songurl)+"&mode="+str(MODE_UNFAVORITE)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid)
273	menuItems = []
274	menuItems.append(("Grooveshark Favorite", "XBMC.RunPlugin("+fav+")"))
275	menuItems.append(("Not Grooveshark Favorite", "XBMC.RunPlugin("+unfav+")"))
276	songItem.addContextMenuItems(menuItems, replaceItems=False)
277	return xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=songItem,isFolder=False)
278
279	def _addDir(self, name, url, mode, iconimage, id):
280	u=sys.argv[0]+"?url="+urllib.quote_plus(url)+"&mode="+str(mode)+"&name="+urllib.quote_plus(name)+"&id="+str(id)
281	dir=xbmcgui.ListItem(name, iconImage=iconimage, thumbnailImage=iconimage)
282	dir.setInfo( type="Music", infoLabels={ "Title": name } )
283	# Codes from http://xbmc-scripting.googlecode.com/svn/trunk/Script%20Templates/common/gui/codes.py
284	menuItems = []
285	menuItems.append(("Select", "XBMC.executebuiltin(Action(7))"))
286	dir.addContextMenuItems(menuItems, replaceItems=True)
287	return xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=dir,isFolder=True)
288
289	def get_params():
290	param=[]
291	paramstring=sys.argv[2]
292	if len(paramstring)>=2:
293	params=sys.argv[2]
294	cleanedparams=params.replace('?','')
295	if (params[len(params)-1]=='/'):
296	params=params[0:len(params)-2]
297	pairsofparams=cleanedparams.split('&')
298	param={}
299	for i in range(len(pairsofparams)):
300	splitparams={}
301	splitparams=pairsofparams[i].split('=')
302	if (len(splitparams))==2:
303	param[splitparams[0]]=splitparams[1]
304	print param
305	return param
306
307	grooveshark = Groveshark();
308
309	params=get_params()
310	url=None
311	name=None
312	mode=None
313	id=None
314
315	try: url=urllib.unquote_plus(params["url"])
316	except: pass
317	try: name=urllib.unquote_plus(params["name"])
318	except: pass
319	try: mode=int(params["mode"])
320	except: pass
321	try: id=int(params["id"])
322	except: pass
323
324	if (id > 0):
325	lastID = id
326
327	if mode==None:
328	grooveshark.categories()
329
330	elif mode==MODE_SEARCH_SONGS:
331	grooveshark.searchSongs()
332
333	elif mode==MODE_SEARCH_ALBUMS:
334	grooveshark.searchAlbums()
335
336	elif mode==MODE_SEARCH_ARTISTS:
337	grooveshark.searchArtists()
338
339	elif mode==MODE_POPULAR:
340	grooveshark.popular()
341
342	elif mode==MODE_PLAYLISTS:
343	grooveshark.playlists()
344
345	elif mode==MODE_FAVORITES:
346	grooveshark.favorites()
347
348	elif mode==MODE_SONG:
349	try: name=urllib.unquote_plus(params["name"])
350	except: pass
351	try: album=urllib.unquote_plus(params["album"])
352	except: pass
353	try: artist=urllib.unquote_plus(params["artist"])
354	except: pass
355	try: duration=int(params["duration"])
356	except: pass
357	grooveshark.song(url, name, album, artist, duration)
358
359	elif mode==MODE_ARTIST:
360	grooveshark.artist(lastID)
361
362	elif mode==MODE_ALBUM:
363	grooveshark.album(lastID)
364
365	elif mode==MODE_PLAYLIST:
366	grooveshark.playlist(lastID)
367
368	elif mode==MODE_FAVORITE:
369	grooveshark.favorite(lastID)
370
371	elif mode==MODE_UNFAVORITE:
372	grooveshark.unfavorite(lastID)
373
374	if (mode < MODE_SONG):
375	xbmcplugin.endOfDirectory(int(sys.argv[1]))