default.py

   1 # Copyright 2011 Stephen Denham
   2
   3 #    This file is part of xbmc-groove.
   4 #
   5 #    xbmc-groove is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation, either version 3 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    xbmc-groove is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with xbmc-groove.  If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 import urllib, sys, os, shutil, re, pickle, time, tempfile, xbmcaddon, xbmcplugin, xbmcgui, xbmc
  20
  21 __addon__     = xbmcaddon.Addon('plugin.audio.groove')
  22 __addonname__ = __addon__.getAddonInfo('name')
  23 __cwd__       = __addon__.getAddonInfo('path')
  24 __author__    = __addon__.getAddonInfo('author')
  25 __version__   = __addon__.getAddonInfo('version')
  26 __language__  = __addon__.getLocalizedString
  27
  28
  29 MODE_SEARCH_SONGS = 1
  30 MODE_SEARCH_ALBUMS = 2
  31 MODE_SEARCH_ARTISTS = 3
  32 MODE_SEARCH_ARTISTS_ALBUMS = 4
  33 MODE_SEARCH_PLAYLISTS = 5
  34 MODE_ARTIST_POPULAR = 6
  35 MODE_POPULAR_SONGS = 7
  36 MODE_FAVORITES = 8
  37 MODE_PLAYLISTS = 9
  38 MODE_ALBUM = 10
  39 MODE_ARTIST = 11
  40 MODE_PLAYLIST = 12
  41 MODE_SONG_PAGE = 13
  42 MODE_SIMILAR_ARTISTS = 14
  43 MODE_SONG = 15
  44 MODE_FAVORITE = 16
  45 MODE_UNFAVORITE = 17
  46 MODE_MAKE_PLAYLIST = 18
  47 MODE_REMOVE_PLAYLIST = 19
  48 MODE_RENAME_PLAYLIST = 20
  49 MODE_REMOVE_PLAYLIST_SONG = 21
  50 MODE_ADD_PLAYLIST_SONG = 22
  51
  52 ACTION_MOVE_LEFT = 1
  53 ACTION_MOVE_UP = 3
  54 ACTION_MOVE_DOWN = 4
  55 ACTION_PAGE_UP = 5
  56 ACTION_PAGE_DOWN = 6
  57 ACTION_SELECT_ITEM = 7
  58 ACTION_PREVIOUS_MENU = 10
  59
  60 # Formats for track labels
  61 ARTIST_ALBUM_NAME_LABEL = 0
  62 NAME_ALBUM_ARTIST_LABEL = 1
  63
  64 # Stream marking time (seconds)
  65 STREAM_MARKING_TIME = 30
  66 # Retry URL
  67 STREAM_RETRY = 10
  68
  69 songMarkTime = 0
  70 player = xbmc.Player()
  71 playTimer = None
  72
  73 baseDir = __cwd__
  74 resDir = xbmc.translatePath(os.path.join(baseDir, 'resources'))
  75 libDir = xbmc.translatePath(os.path.join(resDir,  'lib'))
  76 imgDir = xbmc.translatePath(os.path.join(resDir,  'img'))
  77 cacheDir = os.path.join(xbmc.translatePath('special://masterprofile/addon_data/'), os.path.basename(baseDir))
  78 thumbDirName = 'thumb'
  79 thumbDir = os.path.join('special://masterprofile/addon_data/', os.path.basename(baseDir), thumbDirName)
  80
  81 baseModeUrl = 'plugin://plugin.audio.groove/'
  82 playlistUrl = baseModeUrl + '?mode=' + str(MODE_PLAYLIST)
  83 playlistsUrl = baseModeUrl + '?mode=' + str(MODE_PLAYLISTS)
  84 favoritesUrl = baseModeUrl + '?mode=' + str(MODE_FAVORITES)
  85
  86 searchArtistsAlbumsName = __language__(30006)
  87
  88 thumbDef = os.path.join(imgDir, 'default.tbn')
  89 listBackground = os.path.join(imgDir, 'listbackground.png')
  90
  91 sys.path.append (libDir)
  92 from GroovesharkAPI import GrooveAPI
  93 from threading import Event, Thread
  94
  95 try:
  96     groovesharkApi = GrooveAPI()
  97     if groovesharkApi.pingService() != True:
  98         raise StandardError(__language__(30007))
  99 except:
 100     dialog = xbmcgui.Dialog(__language__(30008),__language__(30009),__language__(30010))
 101     dialog.ok()
 102     sys.exit(-1)
 103
 104 # Mark song as playing or played
 105 def markSong(songid, duration):
 106     global songMarkTime
 107     global playTimer
 108     global player
 109     if player.isPlayingAudio():
 110         tNow = player.getTime()
 111         if tNow >= STREAM_MARKING_TIME and songMarkTime == 0:
 112             groovesharkApi.markStreamKeyOver30Secs()
 113             songMarkTime = tNow
 114         elif duration > tNow and duration - tNow < 2 and songMarkTime >= STREAM_MARKING_TIME:
 115             playTimer.cancel()
 116             songMarkTime = 0
 117             groovesharkApi.markSongComplete(songid)
 118     else:
 119         playTimer.cancel()
 120         songMarkTime = 0
 121
 122 class _Info:
 123     def __init__( self, *args, **kwargs ):
 124         self.__dict__.update( kwargs )
 125
 126 # Window dialog to select a grooveshark playlist
 127 class GroovesharkPlaylistSelect(xbmcgui.WindowDialog):
 128
 129     def __init__(self, items=[]):
 130         gap = int(self.getHeight()/100)
 131         w = int(self.getWidth()*0.5)
 132         h = self.getHeight()-30*gap
 133         rw = self.getWidth()
 134         rh = self.getHeight()
 135         x = rw/2 - w/2
 136         y = rh/2 -h/2
 137
 138         self.imgBg = xbmcgui.ControlImage(x+gap, 5*gap+y, w-2*gap, h-5*gap, listBackground)
 139         self.addControl(self.imgBg)
 140
 141         self.playlistControl = xbmcgui.ControlList(2*gap+x, y+3*gap+30, w-4*gap, h-10*gap, textColor='0xFFFFFFFF', selectedColor='0xFFFF4242', itemTextYOffset=0, itemHeight=50, alignmentY = 0)
 142         self.addControl(self.playlistControl)
 143
 144         self.lastPos = 0
 145         self.isSelecting = False
 146         self.selected = -1
 147         listitems = []
 148         for playlist in items:
 149             listitems.append(xbmcgui.ListItem(playlist[0]))
 150         listitems.append(xbmcgui.ListItem(__language__(30011)))
 151         self.playlistControl.addItems(listitems)
 152         self.setFocus(self.playlistControl)
 153         self.playlistControl.selectItem(0)
 154         item = self.playlistControl.getListItem(self.lastPos)
 155         item.select(True)
 156
 157     # Highlight selected item
 158     def setHighlight(self):
 159         if self.isSelecting:
 160             return
 161         else:
 162             self.isSelecting = True
 163
 164         pos = self.playlistControl.getSelectedPosition()
 165         if pos >= 0:
 166             item = self.playlistControl.getListItem(self.lastPos)
 167             item.select(False)
 168             item = self.playlistControl.getListItem(pos)
 169             item.select(True)
 170             self.lastPos = pos
 171         self.isSelecting = False
 172
 173     # Control - select
 174     def onControl(self, control):
 175         if control == self.playlistControl:
 176             self.selected = self.playlistControl.getSelectedPosition()
 177             self.close()
 178
 179     # Action - close or up/down
 180     def onAction(self, action):
 181         if action == ACTION_PREVIOUS_MENU:
 182             self.selected = -1
 183             self.close()
 184         elif action == ACTION_MOVE_UP or action == ACTION_MOVE_DOWN or action == ACTION_PAGE_UP or action == ACTION_PAGE_DOWN == 6:
 185             self.setFocus(self.playlistControl)
 186             self.setHighlight()
 187
 188
 189 class PlayTimer(Thread):
 190     # interval -- floating point number specifying the number of seconds to wait before executing function
 191     # function -- the function (or callable object) to be executed
 192
 193     # iterations -- integer specifying the number of iterations to perform
 194     # args -- list of positional arguments passed to function
 195     # kwargs -- dictionary of keyword arguments passed to function
 196
 197     def __init__(self, interval, function, iterations=0, args=[], kwargs={}):
 198         Thread.__init__(self)
 199         self.interval = interval
 200         self.function = function
 201         self.iterations = iterations
 202         self.args = args
 203         self.kwargs = kwargs
 204         self.finished = Event()
 205
 206     def run(self):
 207         count = 0
 208         while not self.finished.isSet() and (self.iterations <= 0 or count < self.iterations):
 209             self.finished.wait(self.interval)
 210             if not self.finished.isSet():
 211                 self.function(*self.args, **self.kwargs)
 212                 count += 1
 213
 214     def cancel(self):
 215         self.finished.set()
 216
 217     def setIterations(self, iterations):
 218         self.iterations = iterations
 219
 220
 221     def getTime(self):
 222         return self.iterations * self.interval
 223
 224
 225 class Grooveshark:
 226
 227     albumImg = xbmc.translatePath(os.path.join(imgDir, 'album.png'))
 228     artistImg = xbmc.translatePath(os.path.join(imgDir, 'artist.png'))
 229     artistsAlbumsImg = xbmc.translatePath(os.path.join(imgDir, 'artistsalbums.png'))
 230     favoritesImg = xbmc.translatePath(os.path.join(imgDir, 'favorites.png'))
 231     playlistImg = xbmc.translatePath(os.path.join(imgDir, 'playlist.png'))
 232     usersplaylistsImg = xbmc.translatePath(os.path.join(imgDir, 'usersplaylists.png'))
 233     popularSongsImg = xbmc.translatePath(os.path.join(imgDir, 'popularSongs.png'))
 234     popularSongsArtistImg = xbmc.translatePath(os.path.join(imgDir, 'popularSongsArtist.png'))
 235     songImg = xbmc.translatePath(os.path.join(imgDir, 'song.png'))
 236     defImg = xbmc.translatePath(os.path.join(imgDir, 'default.tbn'))
 237     fanImg = xbmc.translatePath(os.path.join(baseDir, 'fanart.png'))
 238
 239     settings = xbmcaddon.Addon(id='plugin.audio.groove')
 240     songsearchlimit = int(settings.getSetting('songsearchlimit'))
 241     albumsearchlimit = int(settings.getSetting('albumsearchlimit'))
 242     artistsearchlimit = int(settings.getSetting('artistsearchlimit'))
 243     songspagelimit = int(settings.getSetting('songspagelimit'))
 244     username = settings.getSetting('username')
 245     password = settings.getSetting('password')
 246
 247     userid = 0
 248
 249     def __init__( self ):
 250         self._handle = int(sys.argv[1])
 251         self.setDebug()
 252         if os.path.isdir(cacheDir) == False:
 253             os.makedirs(cacheDir)
 254             if self.debug:
 255                 xbmc.log(__language__(30012) + " " + cacheDir)
 256         artDir = xbmc.translatePath(thumbDir)
 257         if os.path.isdir(artDir) == False:
 258             os.makedirs(artDir)
 259             if self.debug:
 260                 xbmc.log(__language__(30012) + " " + artDir)
 261
 262     # Top-level menu
 263     def categories(self):
 264
 265         self.userid = self._get_login()
 266
 267         # Setup
 268         xbmcplugin.setPluginFanart(int(sys.argv[1]), self.fanImg)
 269
 270         self._add_dir(__language__(30013), '', MODE_SEARCH_SONGS, self.songImg, 0)
 271         self._add_dir(__language__(30014), '', MODE_SEARCH_ALBUMS, self.albumImg, 0)
 272         self._add_dir(__language__(30015), '', MODE_SEARCH_ARTISTS, self.artistImg, 0)
 273         self._add_dir(searchArtistsAlbumsName, '', MODE_SEARCH_ARTISTS_ALBUMS, self.artistsAlbumsImg, 0)
 274         # Not supported by key
 275         #self._add_dir("Search for user's playlists...", '', MODE_SEARCH_PLAYLISTS, self.usersplaylistsImg, 0)
 276         self._add_dir(__language__(30016), '', MODE_ARTIST_POPULAR, self.popularSongsArtistImg, 0)
 277         self._add_dir(__language__(30017), '', MODE_POPULAR_SONGS, self.popularSongsImg, 0)
 278         if (self.userid != 0):
 279             self._add_dir(__language__(30018), '', MODE_FAVORITES, self.favoritesImg, 0)
 280             self._add_dir(__language__(30019), '', MODE_PLAYLISTS, self.playlistImg, 0)
 281
 282     # Search for songs
 283     def searchSongs(self):
 284         query = self._get_keyboard(default="", heading=__language__(30020))
 285         if (query != ''):
 286             songs = groovesharkApi.getSongSearchResults(query, limit = self.songsearchlimit)
 287             if (len(songs) > 0):
 288                 self._add_songs_directory(songs)
 289             else:
 290                 dialog = xbmcgui.Dialog()
 291                 dialog.ok(__language__(30008), __language__(30021))
 292                 self.categories()
 293         else:
 294             self.categories()
 295
 296     # Search for albums
 297     def searchAlbums(self):
 298         query = self._get_keyboard(default="", heading=__language__(30022))
 299         if (query != ''):
 300             albums = groovesharkApi.getAlbumSearchResults(query, limit = self.albumsearchlimit)
 301             if (len(albums) > 0):
 302                 self._add_albums_directory(albums)
 303             else:
 304                 dialog = xbmcgui.Dialog()
 305                 dialog.ok(__language__(30008), __language__(30023))
 306                 self.categories()
 307         else:
 308             self.categories()
 309
 310     # Search for artists
 311     def searchArtists(self):
 312         query = self._get_keyboard(default="", heading=__language__(30024))
 313         if (query != ''):
 314             artists = groovesharkApi.getArtistSearchResults(query, limit = self.artistsearchlimit)
 315             if (len(artists) > 0):
 316                 self._add_artists_directory(artists)
 317             else:
 318                 dialog = xbmcgui.Dialog()
 319                 dialog.ok(__language__(30008), __language__(30025))
 320                 self.categories()
 321         else:
 322             self.categories()
 323
 324     # Search for playlists
 325     def searchPlaylists(self):
 326         query = self._get_keyboard(default="", heading=__language__(30026))
 327         if (query != ''):
 328             playlists = groovesharkApi.getUserPlaylistsByUsername(query)
 329             if (len(playlists) > 0):
 330                 self._add_playlists_directory(playlists)
 331             else:
 332                 dialog = xbmcgui.Dialog()
 333                 dialog.ok(__language__(30008), __language__(30027))
 334                 self.categories()
 335         else:
 336             self.categories()
 337
 338     # Search for artists albums
 339     def searchArtistsAlbums(self, artistName = None):
 340         if artistName == None or artistName == searchArtistsAlbumsName:
 341             query = self._get_keyboard(default="", heading=__language__(30028))
 342         else:
 343             query = artistName
 344         if (query != ''):
 345             artists = groovesharkApi.getArtistSearchResults(query, limit = self.artistsearchlimit)
 346             if (len(artists) > 0):
 347                 artist = artists[0]
 348                 artistID = artist[1]
 349                 if self.debug:
 350                     xbmc.log("Found " + artist[0] + "...")
 351                 albums = groovesharkApi.getArtistAlbums(artistID, limit = self.albumsearchlimit)
 352                 if (len(albums) > 0):
 353                     self._add_albums_directory(albums, artistID)
 354                 else:
 355                     dialog = xbmcgui.Dialog()
 356                     dialog.ok(__language__(30008), __language__(30029))
 357                     self.categories()
 358             else:
 359                 dialog = xbmcgui.Dialog()
 360                 dialog.ok(__language__(30008), __language__(30030))
 361                 self.categories()
 362         else:
 363             self.categories()
 364
 365     # Get my favorites
 366     def favorites(self):
 367         userid = self._get_login()
 368         if (userid != 0):
 369             favorites = groovesharkApi.getUserFavoriteSongs()
 370             if (len(favorites) > 0):
 371                 self._add_songs_directory(favorites, isFavorites=True)
 372             else:
 373                 dialog = xbmcgui.Dialog()
 374                 dialog.ok(__language__(30008), __language__(30031))
 375                 self.categories()
 376
 377     # Get popular songs
 378     def popularSongs(self):
 379         popular = groovesharkApi.getPopularSongsToday(limit = self.songsearchlimit)
 380         if (len(popular) > 0):
 381             self._add_songs_directory(popular)
 382         else:
 383             dialog = xbmcgui.Dialog()
 384             dialog.ok(__language__(30008), __language__(30032))
 385             self.categories()
 386
 387     # Get my playlists
 388     def playlists(self):
 389         userid = self._get_login()
 390         if (userid != 0):
 391             playlists = groovesharkApi.getUserPlaylists()
 392             if (len(playlists) > 0):
 393                 self._add_playlists_directory(playlists)
 394             else:
 395                 dialog = xbmcgui.Dialog()
 396                 dialog.ok(__language__(30008), __language__(30033))
 397                 self.categories()
 398         else:
 399             dialog = xbmcgui.Dialog()
 400             dialog.ok(__language__(30008), __language__(30034), __language__(30035))
 401
 402     # Make songs a favorite
 403     def favorite(self, songid):
 404         userid = self._get_login()
 405         if (userid != 0):
 406             if self.debug:
 407                 xbmc.log("Favorite song: " + str(songid))
 408             groovesharkApi.addUserFavoriteSong(songID = songid)
 409             xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ', ' + __language__(30036) + ', 1000, ' + thumbDef + ')')
 410         else:
 411             dialog = xbmcgui.Dialog()
 412             dialog.ok(__language__(30008), __language__(30034), __language__(30037))
 413
 414     # Remove song from favorites
 415     def unfavorite(self, songid, prevMode=0):
 416         userid = self._get_login()
 417         if (userid != 0):
 418             if self.debug:
 419                 xbmc.log("Unfavorite song: " + str(songid) + ', previous mode was ' + str(prevMode))
 420             groovesharkApi.removeUserFavoriteSongs(songIDs = songid)
 421             xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ', ' + __language__(30038) + ', 1000, ' + thumbDef + ')')
 422             # Refresh to remove item from directory
 423             if (int(prevMode) == MODE_FAVORITES):
 424                 xbmc.executebuiltin("Container.Refresh(" + favoritesUrl + ")")
 425         else:
 426             dialog = xbmcgui.Dialog()
 427             dialog.ok(__language__(30008), __language__(30034), __language__(30039))
 428
 429
 430     # Show selected album
 431     def album(self, albumid):
 432         album = groovesharkApi.getAlbumSongs(albumid, limit = self.songsearchlimit)
 433         self._add_songs_directory(album, trackLabelFormat=NAME_ALBUM_ARTIST_LABEL)
 434
 435     # Show selected artist
 436     def artist(self, artistid):
 437         albums = groovesharkApi.getArtistAlbums(artistid, limit = self.albumsearchlimit)
 438         self._add_albums_directory(albums, artistid)
 439
 440     # Show selected playlist
 441     def playlist(self, playlistid, playlistname):
 442         userid = self._get_login()
 443         if (userid != 0):
 444             songs = groovesharkApi.getPlaylistSongs(playlistid)
 445             self._add_songs_directory(songs, trackLabelFormat=NAME_ALBUM_ARTIST_LABEL, playlistid=playlistid, playlistname=playlistname)
 446         else:
 447             dialog = xbmcgui.Dialog()
 448             dialog.ok(__language__(30008), __language__(30034), __language__(30040))
 449
 450     # Show popular songs of the artist
 451     def artistPopularSongs(self):
 452         query = self._get_keyboard(default="", heading=__language__(30041))
 453         if (query != ''):
 454             artists = groovesharkApi.getArtistSearchResults(query, limit = self.artistsearchlimit)
 455             if (len(artists) > 0):
 456                 artist = artists[0]
 457                 artistID = artist[1]
 458                 if self.debug:
 459                     xbmc.log("Found " + artist[0] + "...")
 460                 songs = groovesharkApi.getArtistPopularSongs(artistID, limit = self.songsearchlimit)
 461                 if (len(songs) > 0):
 462                     self._add_songs_directory(songs, trackLabelFormat=NAME_ALBUM_ARTIST_LABEL)
 463                 else:
 464                     dialog = xbmcgui.Dialog()
 465                     dialog.ok(__language__(30008), __language__(30042))
 466                     self.categories()
 467             else:
 468                 dialog = xbmcgui.Dialog()
 469                 dialog.ok(__language__(30008), __language__(30043))
 470                 self.categories()
 471         else:
 472             self.categories()
 473
 474     # Play a song
 475     def playSong(self, item):
 476         global playTimer
 477         global player
 478         if item != None:
 479             songid = item.getProperty('songid')
 480             url = item.getProperty('url')
 481             if url == '':
 482                 stream = groovesharkApi.getSubscriberStreamKey(songid)
 483                 url = stream['url']
 484             item.setPath(url)
 485             if self.debug:
 486                 xbmc.log("Grooveshark playing: " + url)
 487             xbmcplugin.setResolvedUrl(handle=int(sys.argv[1]), succeeded=True, listitem=item)
 488             # Wait for play then start time
 489             seconds = 0
 490             while seconds < STREAM_MARKING_TIME:
 491                 try:
 492                     if player.isPlayingAudio() == True:
 493                         if playTimer != None:
 494                             playTimer.cancel()
 495                             songMarkTime = 0
 496                         duration = int(item.getProperty('duration'))
 497                         playTimer = PlayTimer(1, markSong, duration, [songid, duration])
 498                         playTimer.start()
 499                         break
 500                 except: pass
 501                 time.sleep(1)
 502                 seconds = seconds + 1
 503                 if (seconds == STREAM_RETRY):
 504                     stream = groovesharkApi.getSubscriberStreamKey(songid)
 505                     url = stream['url']
 506                     item.setPath(url)
 507                     xbmcplugin.setResolvedUrl(handle=int(sys.argv[1]), succeeded=True, listitem=item)
 508         else:
 509             xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ', ' + __language__(30044) + ', 1000, ' + thumbDef + ')')
 510
 511     # Make a song directory item
 512     def songItem(self, songid, name, album, artist, coverart, trackLabelFormat=ARTIST_ALBUM_NAME_LABEL):
 513         songImg = self._get_icon(coverart, 'song-' + str(songid) + "-image")
 514         if int(trackLabelFormat) == NAME_ALBUM_ARTIST_LABEL:
 515             trackLabel = name + " - " + album + " - " + artist
 516         else:
 517             trackLabel = artist + " - " + album + " - " + name
 518         stream = self._getSongStream(songid)
 519         duration = stream['duration']
 520         url = stream['url']
 521         item = xbmcgui.ListItem(label = trackLabel, thumbnailImage=songImg, iconImage=songImg)
 522         item.setInfo( type="music", infoLabels={ "title": name, "album": album, "artist": artist, "duration": duration} )
 523         item.setProperty('mimetype', 'audio/mpeg')
 524         item.setProperty("IsPlayable", "true")
 525         item.setProperty('songid', str(songid))
 526         item.setProperty('coverart', songImg)
 527         item.setProperty('title', name)
 528         item.setProperty('album', album)
 529         item.setProperty('artist', artist)
 530         item.setProperty('duration', str(duration))
 531         item.setProperty('url', str(url))
 532
 533         return item
 534
 535     # Next page of songs
 536     def songPage(self, offset, trackLabelFormat, playlistid = 0, playlistname = ''):
 537         self._add_songs_directory([], trackLabelFormat, offset, playlistid = playlistid, playlistname = playlistname)
 538
 539     # Make a playlist from an album
 540     def makePlaylist(self, albumid, name):
 541         userid = self._get_login()
 542         if (userid != 0):
 543             re.split(' - ',name,1)
 544             nameTokens = re.split(' - ',name,1) # suggested name
 545             name = self._get_keyboard(default=nameTokens[0], heading=__language__(30045))
 546             if name != '':
 547                 album = groovesharkApi.getAlbumSongs(albumid, limit = self.songsearchlimit)
 548                 songids = []
 549                 for song in album:
 550                     songids.append(song[1])
 551                 if groovesharkApi.createPlaylist(name, songids) == 0:
 552                     dialog = xbmcgui.Dialog()
 553                     dialog.ok(__language__(30008), __language__(30046), name)
 554                 else:
 555                     xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ',' + __language__(30047)+ ', 1000, ' + thumbDef + ')')
 556         else:
 557             dialog = xbmcgui.Dialog()
 558             dialog.ok(__language__(30008), __language__(30034), __language__(30048))
 559
 560     # Rename a playlist
 561     def renamePlaylist(self, playlistid, name):
 562         userid = self._get_login()
 563         if (userid != 0):
 564             newname = self._get_keyboard(default=name, heading=__language__(30049))
 565             if newname == '':
 566                 return
 567             elif groovesharkApi.playlistRename(playlistid, newname) == 0:
 568                 dialog = xbmcgui.Dialog()
 569                 dialog.ok(__language__(30008), __language__(30050), name)
 570             else:
 571                 # Refresh to show new item name
 572                 xbmc.executebuiltin("Container.Refresh")
 573         else:
 574             dialog = xbmcgui.Dialog()
 575             dialog.ok(__language__(30008), __language__(30034), __language__(30051))
 576
 577     # Remove a playlist
 578     def removePlaylist(self, playlistid, name):
 579         dialog = xbmcgui.Dialog()
 580         if dialog.yesno(__language__(30008), name, __language__(30052)) == True:
 581             userid = self._get_login()
 582             if (userid != 0):
 583                 if groovesharkApi.playlistDelete(playlistid) == 0:
 584                     dialog = xbmcgui.Dialog()
 585                     dialog.ok(__language__(30008), __language__(30053), name)
 586                 else:
 587                     # Refresh to remove item from directory
 588                     xbmc.executebuiltin("Container.Refresh(" + playlistsUrl + ")")
 589             else:
 590                 dialog = xbmcgui.Dialog()
 591                 dialog.ok(__language__(30008), __language__(30034), __language__(30054))
 592
 593     # Add song to playlist
 594     def addPlaylistSong(self, songid):
 595         userid = self._get_login()
 596         if (userid != 0):
 597             playlists = groovesharkApi.getUserPlaylists()
 598             if (len(playlists) > 0):
 599                 ret = 0
 600                 # Select the playlist
 601                 playlistSelect = GroovesharkPlaylistSelect(items=playlists)
 602                 playlistSelect.setFocus(playlistSelect.playlistControl)
 603                 playlistSelect.doModal()
 604                 i = playlistSelect.selected
 605                 del playlistSelect
 606                 if i > -1:
 607                     # Add a new playlist
 608                     if i >= len(playlists):
 609                         name = self._get_keyboard(default='', heading=__language__(30055))
 610                         if name != '':
 611                             songIds = []
 612                             songIds.append(songid)
 613                             if groovesharkApi.createPlaylist(name, songIds) == 0:
 614                                 dialog = xbmcgui.Dialog()
 615                                 dialog.ok(__language__(30008), __language__(30056), name)
 616                             else:
 617                                 xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ',' + __language__(30057) + ', 1000, ' + thumbDef + ')')
 618                     # Existing playlist
 619                     else:
 620                         playlist = playlists[i]
 621                         playlistid = playlist[1]
 622                         if self.debug:
 623                             xbmc.log("Add song " + str(songid) + " to playlist " + str(playlistid))
 624                         songIDs=[]
 625                         songs = groovesharkApi.getPlaylistSongs(playlistid)
 626                         for song in songs:
 627                             songIDs.append(song[1])
 628                         songIDs.append(songid)
 629                         ret = groovesharkApi.setPlaylistSongs(playlistid, songIDs)
 630                         if ret == False:
 631                             dialog = xbmcgui.Dialog()
 632                             dialog.ok(__language__(30008), __language__(30058))
 633                         else:
 634                             xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ',' + __language__(30059) + ', 1000, ' + thumbDef + ')')
 635             else:
 636                 dialog = xbmcgui.Dialog()
 637                 dialog.ok(__language__(30008), __language__(30060))
 638                 self.categories()
 639         else:
 640             dialog = xbmcgui.Dialog()
 641             dialog.ok(__language__(30008), __language__(30034), __language__(30061))
 642
 643     # Remove song from playlist
 644     def removePlaylistSong(self, playlistid, playlistname, songid):
 645         dialog = xbmcgui.Dialog()
 646         if dialog.yesno(__language__(30008), __language__(30062), __language__(30063)) == True:
 647             userid = self._get_login()
 648             if (userid != 0):
 649                 songs = groovesharkApi.getPlaylistSongs(playlistID)
 650                 songIDs=[]
 651                 for song in songs:
 652                     if (song[1] != songid):
 653                         songIDs.append(song[1])
 654                 ret = groovesharkApi.setPlaylistSongs(playlistID, songIDs)
 655                 if ret == False:
 656                     dialog = xbmcgui.Dialog()
 657                     dialog.ok(__language__(30008), __language__(30064), __language__(30065))
 658                 else:
 659                     # Refresh to remove item from directory
 660                     xbmc.executebuiltin('XBMC.Notification(' + __language__(30008) + ',' + __language__(30066)+ ', 1000, ' + thumbDef + ')')
 661                     xbmc.executebuiltin("Container.Update(" + playlistUrl + "&id="+str(playlistid) + "&name=" + playlistname + ")")
 662             else:
 663                 dialog = xbmcgui.Dialog()
 664                 dialog.ok(__language__(30008), __language__(30034), __language__(30067))
 665
 666     # Find similar artists to searched artist
 667     def similarArtists(self, artistId):
 668         similar = groovesharkApi.getSimilarArtists(artistId, limit = self.artistsearchlimit)
 669         if (len(similar) > 0):
 670             self._add_artists_directory(similar)
 671         else:
 672             dialog = xbmcgui.Dialog()
 673             dialog.ok(__language__(30008), __language__(30068))
 674             self.categories()
 675
 676     # Debug
 677     def setDebug(self):
 678         self.debug = self.settings.getSetting('debug')
 679         if self.debug:
 680             xbmc.log("Debug is on")
 681
 682     # Debug
 683     def getDebug(self):
 684         return self.debug
 685
 686     # Get keyboard input
 687     def _get_keyboard(self, default="", heading="", hidden=False):
 688         kb = xbmc.Keyboard(default, heading, hidden)
 689         kb.doModal()
 690         if (kb.isConfirmed()):
 691             return unicode(kb.getText(), "utf-8")
 692         return ''
 693
 694     # Login to grooveshark
 695     def _get_login(self):
 696         if (self.username == "" or self.password == ""):
 697             dialog = xbmcgui.Dialog()
 698             dialog.ok(__language__(30008), __language__(30069), __language__(30070))
 699             return 0
 700         else:
 701             if self.userid == 0:
 702                 uid = groovesharkApi.login(self.username, self.password)
 703             if (uid != 0):
 704                 return uid
 705             else:
 706                 dialog = xbmcgui.Dialog()
 707                 dialog.ok(__language__(30008), __language__(30069), __language__(30070))
 708                 return 0
 709
 710     # Get a song directory item
 711     def _get_song_item(self, song, trackLabelFormat):
 712         name = song[0]
 713         songid = song[1]
 714         album = song[2]
 715         artist = song[4]
 716         coverart = song[6]
 717         return self.songItem(songid, name, album, artist, coverart, trackLabelFormat)
 718
 719     # File download
 720     def _get_icon(self, url, songid):
 721         if url != 'None':
 722             localThumb = os.path.join(xbmc.translatePath(os.path.join(thumbDir, str(songid)))) + '.tbn'
 723             try:
 724                 if os.path.isfile(localThumb) == False:
 725                     loc = urllib.URLopener()
 726                     loc.retrieve(url, localThumb)
 727             except:
 728                 shutil.copy2(thumbDef, localThumb)
 729             return os.path.join(os.path.join(thumbDir, str(songid))) + '.tbn'
 730         else:
 731             return thumbDef
 732
 733     # Add songs to directory
 734     def _add_songs_directory(self, songs, trackLabelFormat=ARTIST_ALBUM_NAME_LABEL, offset=0, playlistid=0, playlistname='', isFavorites=False):
 735
 736         totalSongs = len(songs)
 737         offset = int(offset)
 738         start = 0
 739         end = totalSongs
 740
 741         # No pages needed
 742         if offset == 0 and totalSongs <= self.songspagelimit:
 743             if self.debug:
 744                 xbmc.log("Found " + str(totalSongs) + " songs...")
 745         # Pages
 746         else:
 747             # Cache all next pages songs
 748             if offset == 0:
 749                 self._setSavedSongs(songs)
 750             else:
 751                 songs = self._getSavedSongs()
 752                 totalSongs = len(songs)
 753
 754             if totalSongs > 0:
 755                 start = offset
 756                 end = min(start + self.songspagelimit,totalSongs)
 757
 758         id = 0
 759         n = start
 760         items = end - start
 761         while n < end:
 762             song = songs[n]
 763             songid = song[1]
 764             stream = self._getSongStream(songid)
 765             if stream['url'] != '':
 766                 item = self._get_song_item(song, trackLabelFormat)
 767                 coverart = item.getProperty('coverart')
 768                 songname = song[0]
 769                 songalbum = song[2]
 770                 songartist = song[4]
 771                 u=sys.argv[0]+"?mode="+str(MODE_SONG)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid) \
 772                 +"&album="+urllib.quote_plus(songalbum) \
 773                 +"&artist="+urllib.quote_plus(songartist) \
 774                 +"&coverart="+urllib.quote_plus(coverart)
 775                 fav=sys.argv[0]+"?mode="+str(MODE_FAVORITE)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid)
 776                 unfav=sys.argv[0]+"?mode="+str(MODE_UNFAVORITE)+"&name="+urllib.quote_plus(songname)+"&id="+str(songid)+"&prevmode="
 777                 menuItems = []
 778                 if isFavorites == True:
 779                     unfav = unfav +str(MODE_FAVORITES)
 780                 else:
 781                     menuItems.append((__language__(30071), "XBMC.RunPlugin("+fav+")"))
 782                 menuItems.append((__language__(30072), "XBMC.RunPlugin("+unfav+")"))
 783                 if playlistid > 0:
 784                     rmplaylstsong=sys.argv[0]+"?playlistid="+str(playlistid)+"&id="+str(songid)+"&mode="+str(MODE_REMOVE_PLAYLIST_SONG)+"&name="+playlistname
 785                     menuItems.append((__language__(30073), "XBMC.RunPlugin("+rmplaylstsong+")"))
 786                 else:
 787                     addplaylstsong=sys.argv[0]+"?id="+str(songid)+"&mode="+str(MODE_ADD_PLAYLIST_SONG)
 788                     menuItems.append((__language__(30074), "XBMC.RunPlugin("+addplaylstsong+")"))
 789                 item.addContextMenuItems(menuItems, replaceItems=False)
 790                 xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=item,isFolder=False, totalItems=items)
 791                 id = id + 1
 792             else:
 793                 end = min(end + 1,totalSongs)
 794                 if self.debug:
 795                     xbmc.log(song[0] + " does not exist.")
 796             n = n + 1
 797
 798         if totalSongs > end:
 799             u=sys.argv[0]+"?mode="+str(MODE_SONG_PAGE)+"&id=playlistid"+"&offset="+str(end)+"&label="+str(trackLabelFormat)+"&name="+playlistname
 800             self._add_dir(__language__(30075) + '...', u, MODE_SONG_PAGE, self.songImg, 0, totalSongs - end)
 801
 802         xbmcplugin.setContent(self._handle, 'songs')
 803         xbmcplugin.setPluginFanart(int(sys.argv[1]), self.fanImg)
 804
 805     # Add albums to directory
 806     def _add_albums_directory(self, albums, artistid=0):
 807         n = len(albums)
 808         itemsExisting = n
 809         if self.debug:
 810             xbmc.log("Found " + str(n) + " albums...")
 811         i = 0
 812         while i < n:
 813             album = albums[i]
 814             albumID = album[3]
 815             if groovesharkApi.getDoesAlbumExist(albumID):
 816                 albumArtistName = album[0]
 817                 albumName = album[2]
 818                 albumImage = self._get_icon(album[4], 'album-' + str(albumID))
 819                 self._add_dir(albumName + " - " + albumArtistName, '', MODE_ALBUM, albumImage, albumID, itemsExisting)
 820             else:
 821                 itemsExisting = itemsExisting - 1
 822             i = i + 1
 823         # Not supported by key
 824         #if artistid > 0:
 825         #    self._add_dir('Similar artists...', '', MODE_SIMILAR_ARTISTS, self.artistImg, artistid)
 826         xbmcplugin.setContent(self._handle, 'albums')
 827         xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_ALBUM_IGNORE_THE)
 828         xbmcplugin.setPluginFanart(int(sys.argv[1]), self.fanImg)
 829
 830     # Add artists to directory
 831     def _add_artists_directory(self, artists):
 832         n = len(artists)
 833         itemsExisting = n
 834         if self.debug:
 835             xbmc.log("Found " + str(n) + " artists...")
 836         i = 0
 837         while i < n:
 838             artist = artists[i]
 839             artistID = artist[1]
 840             if groovesharkApi.getDoesArtistExist(artistID):
 841                 artistName = artist[0]
 842                 self._add_dir(artistName, '', MODE_ARTIST, self.artistImg, artistID, itemsExisting)
 843             else:
 844                 itemsExisting = itemsExisting - 1
 845             i = i + 1
 846         xbmcplugin.setContent(self._handle, 'artists')
 847         xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_ARTIST_IGNORE_THE)
 848         xbmcplugin.setPluginFanart(int(sys.argv[1]), self.fanImg)
 849
 850     # Add playlists to directory
 851     def _add_playlists_directory(self, playlists):
 852         n = len(playlists)
 853         if self.debug:
 854             xbmc.log("Found " + str(n) + " playlists...")
 855         i = 0
 856         while i < n:
 857             playlist = playlists[i]
 858             playlistName = playlist[0]
 859             playlistID = playlist[1]
 860             dir = self._add_dir(playlistName, '', MODE_PLAYLIST, self.playlistImg, playlistID, n)
 861             i = i + 1
 862         xbmcplugin.setContent(self._handle, 'files')
 863         xbmcplugin.addSortMethod(self._handle, xbmcplugin.SORT_METHOD_LABEL)
 864         xbmcplugin.setPluginFanart(int(sys.argv[1]), self.fanImg)
 865
 866     # Add whatever directory
 867     def _add_dir(self, name, url, mode, iconimage, id, items=1):
 868
 869         if url == '':
 870             u=sys.argv[0]+"?mode="+str(mode)+"&name="+urllib.quote_plus(name)+"&id="+str(id)
 871         else:
 872             u = url
 873         dir=xbmcgui.ListItem(name, iconImage=iconimage, thumbnailImage=iconimage)
 874         dir.setInfo( type="Music", infoLabels={ "title": name } )
 875
 876         # Custom menu items
 877         menuItems = []
 878         if mode == MODE_ALBUM:
 879             mkplaylst=sys.argv[0]+"?mode="+str(MODE_MAKE_PLAYLIST)+"&name="+name+"&id="+str(id)
 880             menuItems.append((__language__(30076), "XBMC.RunPlugin("+mkplaylst+")"))
 881         if mode == MODE_PLAYLIST:
 882             rmplaylst=sys.argv[0]+"?mode="+str(MODE_REMOVE_PLAYLIST)+"&name="+urllib.quote_plus(name)+"&id="+str(id)
 883             menuItems.append((__language__(30077), "XBMC.RunPlugin("+rmplaylst+")"))
 884             mvplaylst=sys.argv[0]+"?mode="+str(MODE_RENAME_PLAYLIST)+"&name="+urllib.quote_plus(name)+"&id="+str(id)
 885             menuItems.append((__language__(30078), "XBMC.RunPlugin("+mvplaylst+")"))
 886
 887         dir.addContextMenuItems(menuItems, replaceItems=False)
 888
 889         return xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=u,listitem=dir,isFolder=True, totalItems=items)
 890
 891     def _getSavedSongs(self):
 892         path = os.path.join(cacheDir, 'songs.dmp')
 893         try:
 894             f = open(path, 'rb')
 895             songs = pickle.load(f)
 896             f.close()
 897         except:
 898             songs = []
 899             pass
 900         return songs
 901
 902     def _setSavedSongs(self, songs):
 903         try:
 904             # Create the 'data' directory if it doesn't exist.
 905             if not os.path.exists(cacheDir):
 906                 os.makedirs(cacheDir)
 907             path = os.path.join(cacheDir, 'songs.dmp')
 908             f = open(path, 'wb')
 909             pickle.dump(songs, f, protocol=pickle.HIGHEST_PROTOCOL)
 910             f.close()
 911         except:
 912             xbmc.log("An error occurred saving songs")
 913             pass
 914
 915     def _getSongStream(self, songid):
 916         id = int(songid)
 917         duration = -1
 918         streams = []
 919         url = ''
 920         path = os.path.join(cacheDir, 'streams.dmp')
 921         try:
 922             f = open(path, 'rb')
 923             streams = pickle.load(f)
 924             for song in streams:
 925                 if song[0] == id:
 926                     duration = song[1]
 927                     url = song[2]
 928                     break;
 929             f.close()
 930         except:
 931             pass
 932
 933         if duration < 0 and groovesharkApi.getDoesSongExist(songid):
 934             stream = groovesharkApi.getSubscriberStreamKey(songid)
 935             url = stream['url']
 936             usecs = stream['uSecs']
 937             if usecs < 60000000:
 938                 usecs = usecs * 10 # Some durations are 10x to small
 939             duration = usecs / 1000000
 940             song = [id, duration, url]
 941             streams.append(song)
 942             self._setSongStream(streams)
 943
 944         return {'duration':duration, 'url':url}
 945
 946     def _setSongStream(self, streams):
 947         try:
 948             # Create the 'data' directory if it doesn't exist.
 949             if not os.path.exists(cacheDir):
 950                 os.makedirs(cacheDir)
 951             path = os.path.join(cacheDir, 'streams.dmp')
 952             f = open(path, 'wb')
 953             pickle.dump(streams, f, protocol=pickle.HIGHEST_PROTOCOL)
 954             f.close()
 955         except:
 956             xbmc.log("An error occurred saving streams")
 957             pass
 958
 959
 960 # Parse URL parameters
 961 def get_params():
 962     param=[]
 963     paramstring=sys.argv[2]
 964     if grooveshark.getDebug():
 965         xbmc.log(paramstring)
 966     if len(paramstring)>=2:
 967         params=sys.argv[2]
 968         cleanedparams=params.replace('?','')
 969         if (params[len(params)-1]=='/'):
 970             params=params[0:len(params)-2]
 971         pairsofparams=cleanedparams.split('&')
 972         param={}
 973         for i in range(len(pairsofparams)):
 974             splitparams={}
 975             splitparams=pairsofparams[i].split('=')
 976             if (len(splitparams))==2:
 977                 param[splitparams[0]]=splitparams[1]
 978     return param
 979
 980 # Main
 981 grooveshark = Grooveshark();
 982 grooveshark.setDebug()
 983 groovesharkApi.setDebug(grooveshark.getDebug())
 984
 985 params=get_params()
 986 mode=None
 987 try: mode=int(params["mode"])
 988 except: pass
 989 id=0
 990 try: id=int(params["id"])
 991 except: pass
 992 name = None
 993 try: name=urllib.unquote_plus(params["name"])
 994 except: pass
 995
 996 # Call function for URL
 997 if mode==None:
 998     grooveshark.categories()
 999
1000 elif mode==MODE_SEARCH_SONGS:
1001     grooveshark.searchSongs()
1002
1003 elif mode==MODE_SEARCH_ALBUMS:
1004     grooveshark.searchAlbums()
1005
1006 elif mode==MODE_SEARCH_ARTISTS:
1007     grooveshark.searchArtists()
1008
1009 elif mode==MODE_SEARCH_ARTISTS_ALBUMS:
1010     grooveshark.searchArtistsAlbums(name)
1011
1012 elif mode==MODE_SEARCH_PLAYLISTS:
1013     grooveshark.searchPlaylists()
1014
1015 elif mode==MODE_POPULAR_SONGS:
1016     grooveshark.popularSongs()
1017
1018 elif mode==MODE_ARTIST_POPULAR:
1019     grooveshark.artistPopularSongs()
1020
1021 elif mode==MODE_FAVORITES:
1022     grooveshark.favorites()
1023
1024 elif mode==MODE_PLAYLISTS:
1025     grooveshark.playlists()
1026
1027 elif mode==MODE_SONG_PAGE:
1028     try: offset=urllib.unquote_plus(params["offset"])
1029     except: pass
1030     try: label=urllib.unquote_plus(params["label"])
1031     except: pass
1032     grooveshark.songPage(offset, label, id, name)
1033
1034 elif mode==MODE_SONG:
1035     try: album=urllib.unquote_plus(params["album"])
1036     except: pass
1037     try: artist=urllib.unquote_plus(params["artist"])
1038     except: pass
1039     try: coverart=urllib.unquote_plus(params["coverart"])
1040     except: pass
1041     song = grooveshark.songItem(id, name, album, artist, coverart)
1042     grooveshark.playSong(song)
1043
1044 elif mode==MODE_ARTIST:
1045     grooveshark.artist(id)
1046
1047 elif mode==MODE_ALBUM:
1048     grooveshark.album(id)
1049
1050 elif mode==MODE_PLAYLIST:
1051     grooveshark.playlist(id, name)
1052
1053 elif mode==MODE_FAVORITE:
1054     grooveshark.favorite(id)
1055
1056 elif mode==MODE_UNFAVORITE:
1057     try: prevMode=int(urllib.unquote_plus(params["prevmode"]))
1058     except:
1059         prevMode = 0
1060     grooveshark.unfavorite(id, prevMode)
1061
1062 elif mode==MODE_SIMILAR_ARTISTS:
1063     grooveshark.similarArtists(id)
1064
1065 elif mode==MODE_MAKE_PLAYLIST:
1066     grooveshark.makePlaylist(id, name)
1067
1068 elif mode==MODE_REMOVE_PLAYLIST:
1069     grooveshark.removePlaylist(id, name)
1070
1071 elif mode==MODE_RENAME_PLAYLIST:
1072     grooveshark.renamePlaylist(id, name)
1073
1074 elif mode==MODE_REMOVE_PLAYLIST_SONG:
1075     try: playlistID=urllib.unquote_plus(params["playlistid"])
1076     except: pass
1077     grooveshark.removePlaylistSong(playlistID, name, id)
1078
1079 elif mode==MODE_ADD_PLAYLIST_SONG:
1080     grooveshark.addPlaylistSong(id)
1081
1082 if mode < MODE_SONG:
1083     xbmcplugin.endOfDirectory(int(sys.argv[1]))