phones.p_lgvx8600

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 from prototypes import * 4 5 # Make all lg stuff available in this module as well 6 from p_lg import * 7 8 # we are the same as lgvx8500 except as noted below 9 from p_lgvx8500 import * 10 11 # We use LSB for all integer like fields 12 UINT=UINTlsb 13 BOOL=BOOLlsb 14 15 #Play List stuff 16 PLIndexFileName='dload/pl_mgr.dat' 17 PLFilePath='my_music' 18 PLExt='.vpl' 19 PLMaxSize=50 # Max number of items per playlist 20

21 -class call(BaseProtogenClass):

22 __fields=['GPStime', 'dunno1', 'duration', 'dunno2', 'pbentrynum', 'numberlength', 'dunno3', 'pbnumbertype', 'dunno4', 'name', 'number'] 23

24 - def __init__(self, *args, **kwargs):

25 dict={} 26 # What was supplied to this function 27 dict.update(kwargs) 28 # Parent constructor 29 super(call,self).__init__(**dict) 30 if self.__class__ is call: 31 self._update(args,dict)

32 33

34 - def getfields(self):

35 return self.__fields

36 37

38 - def _update(self, args, kwargs):

39 super(call,self)._update(args,kwargs) 40 keys=kwargs.keys() 41 for key in keys: 42 if key in self.__fields: 43 setattr(self, key, kwargs[key]) 44 del kwargs[key] 45 # Were any unrecognized kwargs passed in? 46 if __debug__: 47 self._complainaboutunusedargs(call,kwargs) 48 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

49 # Make all P fields that haven't already been constructed 50 51

52 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

53 'Writes this packet to the supplied buffer' 54 self._bufferstartoffset=buf.getcurrentoffset() 55 self.__field_GPStime.writetobuffer(buf) 56 self.__field_dunno1.writetobuffer(buf) 57 self.__field_duration.writetobuffer(buf) 58 self.__field_dunno2.writetobuffer(buf) 59 self.__field_pbentrynum.writetobuffer(buf) 60 self.__field_numberlength.writetobuffer(buf) 61 self.__field_dunno3.writetobuffer(buf) 62 self.__field_pbnumbertype.writetobuffer(buf) 63 self.__field_dunno4.writetobuffer(buf) 64 self.__field_name.writetobuffer(buf) 65 self.__field_number.writetobuffer(buf) 66 self._bufferendoffset=buf.getcurrentoffset() 67 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

68 69

70 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

71 'Reads this packet from the supplied buffer' 72 self._bufferstartoffset=buf.getcurrentoffset() 73 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 74 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 75 self.__field_GPStime.readfrombuffer(buf) 76 self.__field_dunno1=UINT(**{'sizeinbytes': 4}) 77 self.__field_dunno1.readfrombuffer(buf) 78 self.__field_duration=UINT(**{'sizeinbytes': 4}) 79 self.__field_duration.readfrombuffer(buf) 80 self.__field_dunno2=UINT(**{'sizeinbytes': 2}) 81 self.__field_dunno2.readfrombuffer(buf) 82 self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 83 self.__field_pbentrynum.readfrombuffer(buf) 84 self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 85 self.__field_numberlength.readfrombuffer(buf) 86 self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 87 self.__field_dunno3.readfrombuffer(buf) 88 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 89 self.__field_pbnumbertype.readfrombuffer(buf) 90 self.__field_dunno4=UINT(**{'sizeinbytes': 2}) 91 self.__field_dunno4.readfrombuffer(buf) 92 self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 93 self.__field_name.readfrombuffer(buf) 94 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 95 self.__field_number.readfrombuffer(buf) 96 self._bufferendoffset=buf.getcurrentoffset()

97 98

99 - def __getfield_GPStime(self):

100 return self.__field_GPStime.getvalue()

101

102 - def __setfield_GPStime(self, value):

103 if isinstance(value,GPSDATE): 104 self.__field_GPStime=value 105 else: 106 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})

107

108 - def __delfield_GPStime(self): del self.__field_GPStime

109 110 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 111

112 - def __getfield_dunno1(self):

113 return self.__field_dunno1.getvalue()

114

115 - def __setfield_dunno1(self, value):

116 if isinstance(value,UINT): 117 self.__field_dunno1=value 118 else: 119 self.__field_dunno1=UINT(value,**{'sizeinbytes': 4})

120

121 - def __delfield_dunno1(self): del self.__field_dunno1

122 123 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 124

125 - def __getfield_duration(self):

126 return self.__field_duration.getvalue()

127

128 - def __setfield_duration(self, value):

129 if isinstance(value,UINT): 130 self.__field_duration=value 131 else: 132 self.__field_duration=UINT(value,**{'sizeinbytes': 4})

133

134 - def __delfield_duration(self): del self.__field_duration

135 136 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 137

138 - def __getfield_dunno2(self):

139 return self.__field_dunno2.getvalue()

140

141 - def __setfield_dunno2(self, value):

142 if isinstance(value,UINT): 143 self.__field_dunno2=value 144 else: 145 self.__field_dunno2=UINT(value,**{'sizeinbytes': 2})

146

147 - def __delfield_dunno2(self): del self.__field_dunno2

148 149 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 150

151 - def __getfield_pbentrynum(self):

152 return self.__field_pbentrynum.getvalue()

153

154 - def __setfield_pbentrynum(self, value):

155 if isinstance(value,UINT): 156 self.__field_pbentrynum=value 157 else: 158 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})

159

160 - def __delfield_pbentrynum(self): del self.__field_pbentrynum

161 162 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 163

164 - def __getfield_numberlength(self):

165 return self.__field_numberlength.getvalue()

166

167 - def __setfield_numberlength(self, value):

168 if isinstance(value,UINT): 169 self.__field_numberlength=value 170 else: 171 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})

172

173 - def __delfield_numberlength(self): del self.__field_numberlength

174 175 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 176

177 - def __getfield_dunno3(self):

178 return self.__field_dunno3.getvalue()

179

180 - def __setfield_dunno3(self, value):

181 if isinstance(value,UINT): 182 self.__field_dunno3=value 183 else: 184 self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})

185

186 - def __delfield_dunno3(self): del self.__field_dunno3

187 188 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 189

190 - def __getfield_pbnumbertype(self):

191 return self.__field_pbnumbertype.getvalue()

192

193 - def __setfield_pbnumbertype(self, value):

194 if isinstance(value,UINT): 195 self.__field_pbnumbertype=value 196 else: 197 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})

198

199 - def __delfield_pbnumbertype(self): del self.__field_pbnumbertype

200 201 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 202

203 - def __getfield_dunno4(self):

204 return self.__field_dunno4.getvalue()

205

206 - def __setfield_dunno4(self, value):

207 if isinstance(value,UINT): 208 self.__field_dunno4=value 209 else: 210 self.__field_dunno4=UINT(value,**{'sizeinbytes': 2})

211

212 - def __delfield_dunno4(self): del self.__field_dunno4

213 214 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 215

216 - def __getfield_name(self):

217 return self.__field_name.getvalue()

218

219 - def __setfield_name(self, value):

220 if isinstance(value,USTRING): 221 self.__field_name=value 222 else: 223 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})

224

225 - def __delfield_name(self): del self.__field_name

226 227 name=property(__getfield_name, __setfield_name, __delfield_name, None) 228

229 - def __getfield_number(self):

230 return self.__field_number.getvalue()

231

232 - def __setfield_number(self, value):

233 if isinstance(value,USTRING): 234 self.__field_number=value 235 else: 236 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

237

238 - def __delfield_number(self): del self.__field_number

239 240 number=property(__getfield_number, __setfield_number, __delfield_number, None) 241

242 - def iscontainer(self):

243 return True

244

245 - def containerelements(self):

246 yield ('GPStime', self.__field_GPStime, None) 247 yield ('dunno1', self.__field_dunno1, None) 248 yield ('duration', self.__field_duration, None) 249 yield ('dunno2', self.__field_dunno2, None) 250 yield ('pbentrynum', self.__field_pbentrynum, None) 251 yield ('numberlength', self.__field_numberlength, None) 252 yield ('dunno3', self.__field_dunno3, None) 253 yield ('pbnumbertype', self.__field_pbnumbertype, None) 254 yield ('dunno4', self.__field_dunno4, None) 255 yield ('name', self.__field_name, None) 256 yield ('number', self.__field_number, None)

257 258 259 260

261 -class callhistory(BaseProtogenClass):

262 __fields=['numcalls', 'unknown1', 'calls'] 263

264 - def __init__(self, *args, **kwargs):

265 dict={} 266 # What was supplied to this function 267 dict.update(kwargs) 268 # Parent constructor 269 super(callhistory,self).__init__(**dict) 270 if self.__class__ is callhistory: 271 self._update(args,dict)

272 273

274 - def getfields(self):

275 return self.__fields

276 277

278 - def _update(self, args, kwargs):

279 super(callhistory,self)._update(args,kwargs) 280 keys=kwargs.keys() 281 for key in keys: 282 if key in self.__fields: 283 setattr(self, key, kwargs[key]) 284 del kwargs[key] 285 # Were any unrecognized kwargs passed in? 286 if __debug__: 287 self._complainaboutunusedargs(callhistory,kwargs) 288 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

289 # Make all P fields that haven't already been constructed 290 291

292 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

293 'Writes this packet to the supplied buffer' 294 self._bufferstartoffset=buf.getcurrentoffset() 295 self.__field_numcalls.writetobuffer(buf) 296 self.__field_unknown1.writetobuffer(buf) 297 try: self.__field_calls 298 except: 299 self.__field_calls=LIST(**{'elementclass': call}) 300 self.__field_calls.writetobuffer(buf) 301 self._bufferendoffset=buf.getcurrentoffset() 302 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

303 304

305 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

306 'Reads this packet from the supplied buffer' 307 self._bufferstartoffset=buf.getcurrentoffset() 308 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 309 self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 310 self.__field_numcalls.readfrombuffer(buf) 311 self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 312 self.__field_unknown1.readfrombuffer(buf) 313 self.__field_calls=LIST(**{'elementclass': call}) 314 self.__field_calls.readfrombuffer(buf) 315 self._bufferendoffset=buf.getcurrentoffset()

316 317

318 - def __getfield_numcalls(self):

319 return self.__field_numcalls.getvalue()

320

321 - def __setfield_numcalls(self, value):

322 if isinstance(value,UINT): 323 self.__field_numcalls=value 324 else: 325 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})

326

327 - def __delfield_numcalls(self): del self.__field_numcalls

328 329 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 330

331 - def __getfield_unknown1(self):

332 return self.__field_unknown1.getvalue()

333

334 - def __setfield_unknown1(self, value):

335 if isinstance(value,UINT): 336 self.__field_unknown1=value 337 else: 338 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})

339

340 - def __delfield_unknown1(self): del self.__field_unknown1

341 342 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 343

344 - def __getfield_calls(self):

345 try: self.__field_calls 346 except: 347 self.__field_calls=LIST(**{'elementclass': call}) 348 return self.__field_calls.getvalue()

349

350 - def __setfield_calls(self, value):

351 if isinstance(value,LIST): 352 self.__field_calls=value 353 else: 354 self.__field_calls=LIST(value,**{'elementclass': call})

355

356 - def __delfield_calls(self): del self.__field_calls

357 358 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 359

360 - def iscontainer(self):

361 return True

362

363 - def containerelements(self):

364 yield ('numcalls', self.__field_numcalls, None) 365 yield ('unknown1', self.__field_unknown1, None) 366 yield ('calls', self.__field_calls, None)

367 368 369 370

371 -class PLIndexEntry(BaseProtogenClass):

372 __fields=['pathname', 'dunno'] 373

374 - def __init__(self, *args, **kwargs):

375 dict={} 376 # What was supplied to this function 377 dict.update(kwargs) 378 # Parent constructor 379 super(PLIndexEntry,self).__init__(**dict) 380 if self.__class__ is PLIndexEntry: 381 self._update(args,dict)

382 383

384 - def getfields(self):

385 return self.__fields

386 387

388 - def _update(self, args, kwargs):

389 super(PLIndexEntry,self)._update(args,kwargs) 390 keys=kwargs.keys() 391 for key in keys: 392 if key in self.__fields: 393 setattr(self, key, kwargs[key]) 394 del kwargs[key] 395 # Were any unrecognized kwargs passed in? 396 if __debug__: 397 self._complainaboutunusedargs(PLIndexEntry,kwargs) 398 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

399 # Make all P fields that haven't already been constructed 400 401

402 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

403 'Writes this packet to the supplied buffer' 404 self._bufferstartoffset=buf.getcurrentoffset() 405 self.__field_pathname.writetobuffer(buf) 406 try: self.__field_dunno 407 except: 408 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x105 }) 409 self.__field_dunno.writetobuffer(buf) 410 self._bufferendoffset=buf.getcurrentoffset() 411 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

412 413

414 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

415 'Reads this packet from the supplied buffer' 416 self._bufferstartoffset=buf.getcurrentoffset() 417 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 418 self.__field_pathname=USTRING(**{'sizeinbytes': 264, 'encoding': PHONE_ENCODING }) 419 self.__field_pathname.readfrombuffer(buf) 420 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x105 }) 421 self.__field_dunno.readfrombuffer(buf) 422 self._bufferendoffset=buf.getcurrentoffset()

423 424

425 - def __getfield_pathname(self):

426 return self.__field_pathname.getvalue()

427

428 - def __setfield_pathname(self, value):

429 if isinstance(value,USTRING): 430 self.__field_pathname=value 431 else: 432 self.__field_pathname=USTRING(value,**{'sizeinbytes': 264, 'encoding': PHONE_ENCODING })

433

434 - def __delfield_pathname(self): del self.__field_pathname

435 436 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 437

438 - def __getfield_dunno(self):

439 try: self.__field_dunno 440 except: 441 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x105 }) 442 return self.__field_dunno.getvalue()

443

444 - def __setfield_dunno(self, value):

445 if isinstance(value,UINT): 446 self.__field_dunno=value 447 else: 448 self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0x105 })

449

450 - def __delfield_dunno(self): del self.__field_dunno

451 452 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 453

454 - def iscontainer(self):

455 return True

456

457 - def containerelements(self):

458 yield ('pathname', self.__field_pathname, None) 459 yield ('dunno', self.__field_dunno, None)

460 461 462 463

464 -class PLIndexFile(BaseProtogenClass):

465 __fields=['items'] 466

467 - def __init__(self, *args, **kwargs):

468 dict={} 469 # What was supplied to this function 470 dict.update(kwargs) 471 # Parent constructor 472 super(PLIndexFile,self).__init__(**dict) 473 if self.__class__ is PLIndexFile: 474 self._update(args,dict)

475 476

477 - def getfields(self):

478 return self.__fields

479 480

481 - def _update(self, args, kwargs):

482 super(PLIndexFile,self)._update(args,kwargs) 483 keys=kwargs.keys() 484 for key in keys: 485 if key in self.__fields: 486 setattr(self, key, kwargs[key]) 487 del kwargs[key] 488 # Were any unrecognized kwargs passed in? 489 if __debug__: 490 self._complainaboutunusedargs(PLIndexFile,kwargs) 491 if len(args): 492 dict2={ 'elementclass': PLIndexEntry, 'createdefault': True } 493 dict2.update(kwargs) 494 kwargs=dict2 495 self.__field_items=LIST(*args,**dict2)

496 # Make all P fields that haven't already been constructed 497 498

499 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

500 'Writes this packet to the supplied buffer' 501 self._bufferstartoffset=buf.getcurrentoffset() 502 try: self.__field_items 503 except: 504 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 505 self.__field_items.writetobuffer(buf) 506 self._bufferendoffset=buf.getcurrentoffset() 507 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

508 509

510 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

511 'Reads this packet from the supplied buffer' 512 self._bufferstartoffset=buf.getcurrentoffset() 513 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 514 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 515 self.__field_items.readfrombuffer(buf) 516 self._bufferendoffset=buf.getcurrentoffset()

517 518

519 - def __getfield_items(self):

520 try: self.__field_items 521 except: 522 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 523 return self.__field_items.getvalue()

524

525 - def __setfield_items(self, value):

526 if isinstance(value,LIST): 527 self.__field_items=value 528 else: 529 self.__field_items=LIST(value,**{ 'elementclass': PLIndexEntry, 'createdefault': True })

530

531 - def __delfield_items(self): del self.__field_items

532 533 items=property(__getfield_items, __setfield_items, __delfield_items, None) 534

535 - def iscontainer(self):

536 return True

537

538 - def containerelements(self):

539 yield ('items', self.__field_items, None)

540 541 542 543

544 -class PLSongEntry(BaseProtogenClass):

545 __fields=['pathname', 'tunename', 'artistname', 'albumname', 'genre', 'dunno1', 'date', 'size', 'zero'] 546

547 - def __init__(self, *args, **kwargs):

548 dict={} 549 # What was supplied to this function 550 dict.update(kwargs) 551 # Parent constructor 552 super(PLSongEntry,self).__init__(**dict) 553 if self.__class__ is PLSongEntry: 554 self._update(args,dict)

555 556

557 - def getfields(self):

558 return self.__fields

559 560

561 - def _update(self, args, kwargs):

562 super(PLSongEntry,self)._update(args,kwargs) 563 keys=kwargs.keys() 564 for key in keys: 565 if key in self.__fields: 566 setattr(self, key, kwargs[key]) 567 del kwargs[key] 568 # Were any unrecognized kwargs passed in? 569 if __debug__: 570 self._complainaboutunusedargs(PLSongEntry,kwargs) 571 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

572 # Make all P fields that haven't already been constructed 573 574

575 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

576 'Writes this packet to the supplied buffer' 577 self._bufferstartoffset=buf.getcurrentoffset() 578 self.__field_pathname.writetobuffer(buf) 579 try: self.__field_tunename 580 except: 581 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 582 self.__field_tunename.writetobuffer(buf) 583 try: self.__field_artistname 584 except: 585 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 586 self.__field_artistname.writetobuffer(buf) 587 try: self.__field_albumname 588 except: 589 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 590 self.__field_albumname.writetobuffer(buf) 591 try: self.__field_genre 592 except: 593 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 594 self.__field_genre.writetobuffer(buf) 595 try: self.__field_dunno1 596 except: 597 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 598 self.__field_dunno1.writetobuffer(buf) 599 try: self.__field_date 600 except: 601 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 602 self.__field_date.writetobuffer(buf) 603 self.__field_size.writetobuffer(buf) 604 try: self.__field_zero 605 except: 606 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 607 self.__field_zero.writetobuffer(buf) 608 self._bufferendoffset=buf.getcurrentoffset() 609 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

610 611

612 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

613 'Reads this packet from the supplied buffer' 614 self._bufferstartoffset=buf.getcurrentoffset() 615 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 616 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 617 self.__field_pathname.readfrombuffer(buf) 618 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 619 self.__field_tunename.readfrombuffer(buf) 620 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 621 self.__field_artistname.readfrombuffer(buf) 622 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 623 self.__field_albumname.readfrombuffer(buf) 624 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 625 self.__field_genre.readfrombuffer(buf) 626 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 627 self.__field_dunno1.readfrombuffer(buf) 628 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 629 self.__field_date.readfrombuffer(buf) 630 self.__field_size=UINT(**{'sizeinbytes': 4}) 631 self.__field_size.readfrombuffer(buf) 632 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 633 self.__field_zero.readfrombuffer(buf) 634 self._bufferendoffset=buf.getcurrentoffset()

635 636

637 - def __getfield_pathname(self):

638 return self.__field_pathname.getvalue()

639

640 - def __setfield_pathname(self, value):

641 if isinstance(value,USTRING): 642 self.__field_pathname=value 643 else: 644 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING })

645

646 - def __delfield_pathname(self): del self.__field_pathname

647 648 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 649

650 - def __getfield_tunename(self):

651 try: self.__field_tunename 652 except: 653 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 654 return self.__field_tunename.getvalue()

655

656 - def __setfield_tunename(self, value):

657 if isinstance(value,USTRING): 658 self.__field_tunename=value 659 else: 660 self.__field_tunename=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname })

661

662 - def __delfield_tunename(self): del self.__field_tunename

663 664 tunename=property(__getfield_tunename, __setfield_tunename, __delfield_tunename, None) 665

666 - def __getfield_artistname(self):

667 try: self.__field_artistname 668 except: 669 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 670 return self.__field_artistname.getvalue()

671

672 - def __setfield_artistname(self, value):

673 if isinstance(value,USTRING): 674 self.__field_artistname=value 675 else: 676 self.__field_artistname=USTRING(value,**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' })

677

678 - def __delfield_artistname(self): del self.__field_artistname

679 680 artistname=property(__getfield_artistname, __setfield_artistname, __delfield_artistname, None) 681

682 - def __getfield_albumname(self):

683 try: self.__field_albumname 684 except: 685 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 686 return self.__field_albumname.getvalue()

687

688 - def __setfield_albumname(self, value):

689 if isinstance(value,USTRING): 690 self.__field_albumname=value 691 else: 692 self.__field_albumname=USTRING(value,**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' })

693

694 - def __delfield_albumname(self): del self.__field_albumname

695 696 albumname=property(__getfield_albumname, __setfield_albumname, __delfield_albumname, None) 697

698 - def __getfield_genre(self):

699 try: self.__field_genre 700 except: 701 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 702 return self.__field_genre.getvalue()

703

704 - def __setfield_genre(self, value):

705 if isinstance(value,USTRING): 706 self.__field_genre=value 707 else: 708 self.__field_genre=USTRING(value,**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' })

709

710 - def __delfield_genre(self): del self.__field_genre

711 712 genre=property(__getfield_genre, __setfield_genre, __delfield_genre, None) 713

714 - def __getfield_dunno1(self):

715 try: self.__field_dunno1 716 except: 717 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 718 return self.__field_dunno1.getvalue()

719

720 - def __setfield_dunno1(self, value):

721 if isinstance(value,UINT): 722 self.__field_dunno1=value 723 else: 724 self.__field_dunno1=UINT(value,**{'sizeinbytes': 4, 'default': 2 })

725

726 - def __delfield_dunno1(self): del self.__field_dunno1

727 728 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 729

730 - def __getfield_date(self):

731 try: self.__field_date 732 except: 733 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 734 return self.__field_date.getvalue()

735

736 - def __setfield_date(self, value):

737 if isinstance(value,GPSDATE): 738 self.__field_date=value 739 else: 740 self.__field_date=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() })

741

742 - def __delfield_date(self): del self.__field_date

743 744 date=property(__getfield_date, __setfield_date, __delfield_date, None) 745

746 - def __getfield_size(self):

747 return self.__field_size.getvalue()

748

749 - def __setfield_size(self, value):

750 if isinstance(value,UINT): 751 self.__field_size=value 752 else: 753 self.__field_size=UINT(value,**{'sizeinbytes': 4})

754

755 - def __delfield_size(self): del self.__field_size

756 757 size=property(__getfield_size, __setfield_size, __delfield_size, None) 758

759 - def __getfield_zero(self):

760 try: self.__field_zero 761 except: 762 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 763 return self.__field_zero.getvalue()

764

765 - def __setfield_zero(self, value):

766 if isinstance(value,UINT): 767 self.__field_zero=value 768 else: 769 self.__field_zero=UINT(value,**{'sizeinbytes': 4, 'default': 0 })

770

771 - def __delfield_zero(self): del self.__field_zero

772 773 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 774

775 - def iscontainer(self):

776 return True

777

778 - def containerelements(self):

779 yield ('pathname', self.__field_pathname, None) 780 yield ('tunename', self.__field_tunename, None) 781 yield ('artistname', self.__field_artistname, None) 782 yield ('albumname', self.__field_albumname, None) 783 yield ('genre', self.__field_genre, None) 784 yield ('dunno1', self.__field_dunno1, None) 785 yield ('date', self.__field_date, None) 786 yield ('size', self.__field_size, None) 787 yield ('zero', self.__field_zero, None)

788 789 790 791

792 -class PLPlayListFile(BaseProtogenClass):

793 __fields=['items'] 794

795 - def __init__(self, *args, **kwargs):

796 dict={} 797 # What was supplied to this function 798 dict.update(kwargs) 799 # Parent constructor 800 super(PLPlayListFile,self).__init__(**dict) 801 if self.__class__ is PLPlayListFile: 802 self._update(args,dict)

803 804

805 - def getfields(self):

806 return self.__fields

807 808

809 - def _update(self, args, kwargs):

810 super(PLPlayListFile,self)._update(args,kwargs) 811 keys=kwargs.keys() 812 for key in keys: 813 if key in self.__fields: 814 setattr(self, key, kwargs[key]) 815 del kwargs[key] 816 # Were any unrecognized kwargs passed in? 817 if __debug__: 818 self._complainaboutunusedargs(PLPlayListFile,kwargs) 819 if len(args): 820 dict2={ 'elementclass': PLSongEntry, 'createdefault': True } 821 dict2.update(kwargs) 822 kwargs=dict2 823 self.__field_items=LIST(*args,**dict2)

824 # Make all P fields that haven't already been constructed 825 826

827 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

828 'Writes this packet to the supplied buffer' 829 self._bufferstartoffset=buf.getcurrentoffset() 830 try: self.__field_items 831 except: 832 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 833 self.__field_items.writetobuffer(buf) 834 self._bufferendoffset=buf.getcurrentoffset() 835 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

836 837

838 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

839 'Reads this packet from the supplied buffer' 840 self._bufferstartoffset=buf.getcurrentoffset() 841 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 842 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 843 self.__field_items.readfrombuffer(buf) 844 self._bufferendoffset=buf.getcurrentoffset()

845 846

847 - def __getfield_items(self):

848 try: self.__field_items 849 except: 850 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 851 return self.__field_items.getvalue()

852

853 - def __setfield_items(self, value):

854 if isinstance(value,LIST): 855 self.__field_items=value 856 else: 857 self.__field_items=LIST(value,**{ 'elementclass': PLSongEntry, 'createdefault': True })

858

859 - def __delfield_items(self): del self.__field_items

860 861 items=property(__getfield_items, __setfield_items, __delfield_items, None) 862

863 - def iscontainer(self):

864 return True

865

866 - def containerelements(self):

867 yield ('items', self.__field_items, None)

868

Source Code for Module phones.p_lgvx8600