code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Plugins/Extensions/HbbTV/bookmark.py

   1 class BookmarkData:
   2         def __init__(self, _id, _title, _url, _parent, _type):
   3                 self.mId        = _id
   4                 self.mTitle     = _title
   5                 self.mUrl       = _url
   6                 self.mParent    = _parent
   7                 self.mType      = _type
   8         def dump(self, _intent='  '):
   9                 print "%s-> %d, %s, %s, %d, %d" % (_intent, self.mId, self.mTitle, self.mUrl, self.mParent, self.mType)
  10
  11 class CategoryData:
  12         def __init__(self, _id, _name):
  13                 self.mId        = _id
  14                 self.mName      = _name
  15                 self.mBookmarks = {}
  16
  17         def setBookmarks(self, _bookmarks):
  18                 self.mBookmarks = _bookmarks
  19
  20         def appendBookmark(self, _bookmark):
  21                 self.mBookmarks[_bookmark.mId] = _bookmark
  22
  23         def dump(self):
  24                 print "  -> %d, %s" % (self.mId, self.mName)
  25                 for key in self.mBookmarks.iterkeys():
  26                         self.mBookmarks[key].dump('      ')
  27
  28 import ConfigParser
  29 class SimpleConfigParser:
  30         def __init__(self):
  31                 self.mFileName = None
  32                 self.mConfig = None
  33                 self.mCategoryCurrentIdx = 0
  34                 self.mBookmarkCurrentIdx = 0
  35                 self.mDataValid = False
  36                 self.mPopulateValid = False
  37
  38         def _read(self):
  39                 if self.mDataValid:
  40                         return
  41                 print "populate!!"
  42                 self.mConfig.read(self.mFileName)
  43
  44                 self.mCategoryCurrentIdx = self.getNumber('__SYS__', 'category_current_idx')
  45                 self.mBookmarkCurrentIdx = self.getNumber('__SYS__', 'bookmark_current_idx')
  46                 self.mDataValid = True
  47
  48         def _save(self):
  49                 with open(self.mFileName, 'wb') as bookmarkFile:
  50                         self.mConfig.write(bookmarkFile)
  51                 self.mDataValid = False
  52                 self.mPopulateValid = False
  53
  54         def _del(self, _section, _option=None):
  55                 #print _section, ' :', _option
  56                 if _option is None:
  57                         if not self.exist(_section):
  58                                 return
  59                         self.mConfig.remove_section(_section)
  60                         return
  61                 if not self.exist(_section, _option):
  62                         return
  63                 self.mConfig.remove_option(_section, _option)
  64
  65         def _get(self, _section, _option, _default):
  66                 try:
  67                         data = self.mConfig.get(_section, _option)
  68                 except Exception, e:
  69                         #print e
  70                         return _default
  71                 else :  return data
  72
  73         def _set(self, _section, _option, _value):
  74                 self.mConfig.set(_section, _option, _value)
  75
  76         def exist(self, _section, _option=None):
  77                 if _option is None:
  78                         return self.mConfig.has_section(_section)
  79                 return self.mConfig.has_option(_section, _option)
  80
  81         def setNumber(self, _section, _option, _value):
  82                 self._set(_section, _option, str(_value))
  83
  84         def setString(self, _section, _option, _value):
  85                 self._set(_section, _option, _value)
  86
  87         def getNumber(self, _section, _option, _default=0):
  88                 return int(self._get(_section, _option, _default))
  89
  90         def getString(self, _section, _option, _default=''):
  91                 return self._get(_section, _option, _default)
  92
  93         def delOption(self, _section, _option):
  94                 self._del(_section, _option)
  95
  96         def addSection(self, _section):
  97                 self.mConfig.add_section(_section)
  98
  99         def delSection(self, _section):
 100                 self._del(_section)
 101
 102         def init(self, _fileName):
 103                 self.mFileName = _fileName
 104                 self.mConfig = ConfigParser.RawConfigParser()
 105                 if self.mConfig is None:
 106                         return False
 107                 self._read()
 108                 return True
 109
 110 class BookmarkManager(SimpleConfigParser):
 111         _instance = None
 112         def __new__(cls, *args, **kwargs):
 113             if not cls._instance:
 114                 cls._instance = super(Singleton, cls).__new__(
 115                                    cls, *args, **kwargs)
 116             return cls._instance
 117
 118         def __init__(self, _dbFileName):
 119                 SimpleConfigParser.__init__(self)
 120
 121                 self.mBookmarkRoot = None
 122                 self.mDebugEnable = True
 123
 124                 import os
 125                 if not os.path.exists(_dbFileName):
 126                         f = file('/proc/stb/info/vumodel')
 127                         model = f.read().strip()
 128                         f.close()
 129                         manualmode = (model == "solo2" or model == "duo2")
 130
 131                         os.system('echo "[__SYS__]" > %s'%(_dbFileName))
 132                         os.system('echo "category_current_idx = 1" >> %s'%(_dbFileName))
 133                         if manualmode :
 134                                 os.system('echo "bookmark_current_idx = 2" >> %s'%(_dbFileName))
 135                         else:   os.system('echo "bookmark_current_idx = 1" >> %s'%(_dbFileName))
 136                         os.system('echo "[c-1]" >> %s'%(_dbFileName))
 137                         os.system('echo "id = 1" >> %s'%(_dbFileName))
 138                         os.system('echo "name = My favorite" >> %s'%(_dbFileName))
 139                         os.system('echo "[b-1]" >> %s'%(_dbFileName))
 140                         os.system('echo "url = http://www2.vuplus.com/" >> %s'%(_dbFileName))
 141                         os.system('echo "id = 1" >> %s'%(_dbFileName))
 142                         os.system('echo "parent = 1" >> %s'%(_dbFileName))
 143                         os.system('echo "title = Vuplus Home" >> %s'%(_dbFileName))
 144                         os.system('echo "type = 0" >> %s'%(_dbFileName))
 145                         if manualmode :
 146                                 os.system('echo "[b-2]" >> %s'%(_dbFileName))
 147                                 os.system('echo "url = file:///usr/local/manual/main.html" >> %s'%(_dbFileName))
 148                                 os.system('echo "id = 2" >> %s'%(_dbFileName))
 149                                 os.system('echo "parent = 1" >> %s'%(_dbFileName))
 150                                 os.system('echo "title = User Manual" >> %s'%(_dbFileName))
 151                                 os.system('echo "type = 1" >> %s'%(_dbFileName))
 152                 self.init(_dbFileName)
 153
 154         def message(self, format, params=None):
 155                 if not self.mDebugEnable:
 156                         return
 157                 if params is None:
 158                         print format
 159                 else:   print format % (params)
 160
 161         def getBookmark(self, _title):
 162                 self.populate()
 163                 for key in self.mBookmarkRoot.iterkeys():
 164                         for key2 in self.mBookmarkRoot[key].mBookmarks.iterkeys():
 165                                 if self.mBookmarkRoot[key].mBookmarks[key2].mTitle == _title:
 166                                         return 'b-%d' % (self.mBookmarkRoot[key].mBookmarks[key2].mId)
 167                 return None
 168
 169         def addBookmark(self, _title, _url, _parent, _type):
 170                 if self.getBookmark(_title) is not None:
 171                         return False
 172                 i = self.mBookmarkCurrentIdx + 1
 173                 s = "b-%d" % (i,)
 174                 self.message("add bookmark : %s, %s, %d, %d", (_title, _url, _parent, _type,))
 175
 176                 self.mConfig.add_section(s)
 177                 self.setNumber(s, 'id', i)
 178                 self.setString(s, 'title', _title)
 179                 self.setString(s, 'url', _url)
 180                 self.setNumber(s, 'parent', _parent)
 181                 self.setNumber(s, 'type', _type)
 182                 self.setNumber('__SYS__', 'bookmark_current_idx', i)
 183                 self._save()
 184
 185                 return True
 186
 187         def deleteBookmark(self, _id):
 188                 self.populate()
 189                 self.message("delete bookmark : %d", (_id,))
 190                 self.delSection('b-%d' % (_id,))
 191                 self._save()
 192
 193         def updateBookmark(self, _bookmark):
 194                 self.populate()
 195                 s = "b-%d" % (_bookmark.mId)
 196                 self.message("update bookmark : %s, %s, %d, %d", (_bookmark.mTitle, _bookmark.mUrl, _bookmark.mParent, _bookmark.mType,))
 197                 self.setString(s, 'title', _bookmark.mTitle)
 198                 self.setString(s, 'url', _bookmark.mUrl)
 199                 self.setNumber(s, 'parent', _bookmark.mParent)
 200                 self.setNumber(s, 'type', _bookmark.mType)
 201                 self._save()
 202
 203         def getCategory(self, _name):
 204                 self.populate()
 205                 for key in self.mBookmarkRoot.iterkeys():
 206                         if self.mBookmarkRoot[key].mName == _name:
 207                                 return 'c-%d' % (self.mBookmarkRoot[key].mId)
 208                 return None
 209
 210         def addCategory(self, _name):
 211                 if self.getCategory(_name) is not None:
 212                         return False
 213                 self.message("add category : %s", (_name,))
 214                 i = self.mCategoryCurrentIdx + 1
 215                 s = "c-%d" % (i)
 216
 217                 self.mConfig.add_section(s)
 218                 self.setNumber(s, 'id', i)
 219                 self.setNumber(s, 'name', _name)
 220                 self.setNumber('__SYS__', 'category_current_idx', i)
 221                 self._save()
 222
 223                 return True
 224
 225         def deleteCategory(self, _id):
 226                 self.populate()
 227                 self.message("delete category : %d", (_id,))
 228                 try:
 229                         for key in self.mBookmarkRoot[_id].mBookmarks.iterkeys():
 230                                 self.delSection('b-%d' % (key,))
 231                 except: pass
 232                 self.delSection('c-%d' % (_id,))
 233                 self._save()
 234
 235         def updateCategory(self, _category):
 236                 self.populate()
 237                 self.message("update category : %s", (_category.mName,))
 238                 s = "c-%d" % (_category.mId)
 239                 self.setNumber(s, 'name', _category.mName)
 240                 self._save()
 241
 242         def populate(self):
 243                 cx, bx = 0, 0
 244                 categoryList = {}
 245                 self.message("populate : %d, %d", (self.mPopulateValid, self.mDataValid))
 246
 247                 self._read()
 248                 if self.mPopulateValid:
 249                         return
 250
 251                 while cx <= self.mCategoryCurrentIdx:
 252                         s = 'c-%d' % (cx,)
 253                         i = self.getNumber(s, 'id', -1)
 254                         if i != -1:
 255                                 n = self.getString(s, 'name')
 256                                 categoryList[i] = CategoryData(i, n)
 257                         cx += 1
 258                 sorted(categoryList)
 259                 while bx <= self.mBookmarkCurrentIdx:
 260                         s = 'b-%d' % (bx,)
 261                         i = self.getNumber(s, 'id', -1)
 262                         if i != -1:
 263                                 t = self.getString(s, 'title')
 264                                 u = self.getString(s, 'url')
 265                                 p = self.getNumber(s, 'parent')
 266                                 e = self.getNumber(s, 'type')
 267                                 try:
 268                                         categoryList[p].appendBookmark(BookmarkData(i, t, u, p, e))
 269                                 except Exception, e: self._del(s)
 270                         bx += 1
 271                 for key in categoryList.iterkeys():
 272                         sorted(categoryList[key].mBookmarks)
 273                 self.mBookmarkRoot = categoryList
 274                 self.mPopulateValid = True
 275                 self.dump()
 276
 277         def getBookmarkRoot(self):
 278                 self.populate()
 279                 return self.mBookmarkRoot
 280
 281         def dump(self):
 282                 if not self.mDebugEnable:
 283                         return
 284                 self.populate()
 285                 print "-- snapshot --"
 286                 for key in self.mBookmarkRoot.iterkeys():
 287                         self.mBookmarkRoot[key].dump()
 288                 print "--------------"
 289
 290         @staticmethod
 291         def getInstance():
 292                 return BookmarkManager('/usr/lib/enigma2/python/Plugins/Extensions/HbbTV/bookmark.ini')
 293
 294