56 void SmfMusicServicePrivate::userinfo()

    56 SmfError SmfMusicServicePrivate::userMusicInfo()

    57 	{

    57 	{

    58 	SmfError err = SmfNoError;

    70 	}

    71 	return err;

    71 

    72 	}

    72 void SmfMusicServicePrivate::searchUser(SmfLocation venue, int pageNum, int perPage)

    73 

    73 	{

    74 SmfError SmfMusicServicePrivate::searchArtist ( SmfArtists artist, int pageNum, int perPage )

    75 	{

    76 	SmfError err = SmfNoError;

    79 	m_argFlag = 1;

    82 	

    80 	write<<m_argFlag;

    83 	QByteArray dataToPlugins;

    81 	write<<venue;

    84 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

    82 	write<<m_argFlag;

    85 	m_argFlag = 1;

    83 	write<<pageNum;

    86 	streamToPlugin<<m_argFlag;

    84 	write<<m_argFlag;

    87 	streamToPlugin<<artist;

    85 	write<<perPage;

    88 	streamToPlugin<<m_argFlag;

    89 	streamToPlugin<<pageNum;

    90 	streamToPlugin<<m_argFlag;

    91 	streamToPlugin<<perPage;

    92 	

    93 	write<<dataToPlugins;

    93 	}

   222 	return err;

    94 

   223 	}

    95 void SmfMusicServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

   224 

    96 	{

   225 SmfError SmfMusicServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

   226 	{

   227 	SmfError err = SmfNoError;

   102 	m_argFlag = 1;

   233 	

   103 	write<<m_argFlag;

   234 	QByteArray dataToPlugins;

   104 	write<<operationId;

   235 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   236 	

   237 	m_argFlag = 1;

   238 	streamToPlugin<<m_argFlag;

   239 	streamToPlugin<<operationId;

   107 		write<<m_argFlag;

   242 		streamToPlugin<<m_argFlag;

   108 		write<<*customData;

   243 		streamToPlugin<<*customData;

   113 		write<<m_argFlag;

   248 		streamToPlugin<<m_argFlag;

   114 		}

   249 		}

   250 	

   251 	write<<dataToPlugins;

   123 	}

   260 	return err;

   124 

   261 	}

   125 void SmfMusicServicePrivate::postCurrentPlaying(SmfTrackInfo track) 

   262 

   126 	{

   263 SmfError SmfMusicServicePrivate::postCurrentPlaying(SmfTrackInfo track) 

   264 	{

   265 	SmfError err = SmfNoError;

   132 	m_argFlag = 1;

   271 	

   133 	write<<m_argFlag;

   272 	QByteArray dataToPlugins;

   134 	write<<track;

   273 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   274 	

   275 	m_argFlag = 1;

   276 	streamToPlugin<<m_argFlag;

   277 	streamToPlugin<<track;

   278 	

   279 	write<<dataToPlugins;

   143 	}

   288 	return err;

   144 

   289 	}

   145 void SmfMusicServicePrivate::postRating(SmfTrackInfo track, SmfMusicRating rate) 

   290 

   146 	{

   291 SmfError SmfMusicServicePrivate::postRating(SmfTrackInfo track, SmfMusicRating rate) 

   292 	{

   293 	SmfError err = SmfNoError;

   152 	m_argFlag = 1;

   299 	

   153 	write<<m_argFlag;

   300 	QByteArray dataToPlugins;

   154 	write<<track;

   301 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   155 	write<<m_argFlag;

   302 	

   156 	write<<rate;

   303 	m_argFlag = 1;

   304 	streamToPlugin<<m_argFlag;

   305 	streamToPlugin<<track;

   306 	streamToPlugin<<m_argFlag;

   307 	streamToPlugin<<rate;

   308 	

   309 	write<<dataToPlugins;

   165 	}

   318 	return err;

   166 

   319 	}

   167 void SmfMusicServicePrivate::postComments(SmfTrackInfo track, SmfComment comment) 

   320 

   168 	{

   321 SmfError SmfMusicServicePrivate::postComments(SmfTrackInfo track, SmfComment comment) 

   322 	{

   323 	SmfError err = SmfNoError;

   174 	m_argFlag = 1;

   329 	

   175 	write<<m_argFlag;

   330 	QByteArray dataToPlugins;

   176 	write<<track;

   331 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   177 	write<<m_argFlag;

   332 	

   178 	write<<comment;

   333 	m_argFlag = 1;

   334 	streamToPlugin<<m_argFlag;

   335 	streamToPlugin<<track;

   336 	streamToPlugin<<m_argFlag;

   337 	streamToPlugin<<comment;

   338 	

   339 	write<<dataToPlugins;

   204 			emit m_musicService->userInfoAvailable(m_profile,error);

   381 			emit m_musicService->userMusicInfoAvailable(m_profile,error);

   382 			break;

   383 			}

   384 			

   385 		case SmfMusicSearchArtist:

   386 			{

   387 			SmfArtistsList *m_List = new SmfArtistsList;

   388 			reader>>*m_List;

   389 			

   390 			//ToDo :- not incorporating paging now

   391 			SmfResultPage page;

   392 

   393 			emit m_musicService->searchArtistInfoAvailable(m_List, error, page);

   394 			break;

   395 			}

   396 			

   397 		case SmfMusicSearchAlbum:

   398 			{

   399 			SmfAlbumList *m_List = new SmfAlbumList;

   400 			reader>>*m_List;

   401 			

   402 			//ToDo :- not incorporating paging now

   403 			SmfResultPage page;

   404 

   405 			emit m_musicService->searchAlbumInfoAvailable(m_List, error, page);

   406 			break;

   407 			}

   408 			

   409 		case SmfMusicSearchEvent:

   410 			{

   411 			SmfEventList *m_List = new SmfEventList;

   412 			reader>>*m_List;

   413 			

   414 			//ToDo :- not incorporating paging now

   415 			SmfResultPage page;

   416 

   417 			emit m_musicService->searchEventsInfoAvailable(m_List, error, page);

   418 			break;

   419 			}

   420 		case SmfMusicSearchVenue:

   421 			{

   422 			SmfLocationList *m_List = new SmfLocationList;

   423 			reader>>*m_List;

   424 			

   425 			//ToDo :- not incorporating paging now

   426 			SmfResultPage page;

   427 

   428 			emit m_musicService->searchVenueInfoAvailable(m_List, error, page);

   216 			emit m_musicService->searchInfoAvailable(m_profileList, error, page);

   440 			emit m_musicService->searchUserInfoAvailable(m_profileList, error, page);

   268 void SmfMusicSearchPrivate::recommendations(SmfTrackInfo track, int pageNum, int perPage)

   492 SmfError SmfMusicSearchPrivate::recommendations(SmfTrackInfo track, int pageNum, int perPage)

   269 	{

   493 	{

   494 	SmfError err = SmfNoError;

   275 	m_argFlag = 1;

   500 	

   276 	write<<m_argFlag;

   501 	QByteArray dataToPlugins;

   277 	write<<track;

   502 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   278 	write<<m_argFlag;

   503 	

   279 	write<<pageNum;

   504 	m_argFlag = 1;

   280 	write<<m_argFlag;

   505 	streamToPlugin<<m_argFlag;

   281 	write<<perPage;

   506 	streamToPlugin<<track;

   507 	streamToPlugin<<m_argFlag;

   508 	streamToPlugin<<pageNum;

   509 	streamToPlugin<<m_argFlag;

   510 	streamToPlugin<<perPage;

   511 	

   512 	write<<dataToPlugins;

   285 	int maxalloc = 1000;

   516 	int maxalloc = SmfMusicTracksMaxSize*perPage;

   290 	}

   521 	return err;

   291 

   522 	}

   292 void SmfMusicSearchPrivate::tracks(SmfTrackInfo track, int pageNum, int perPage)

   523 

   293 	{

   524 SmfError SmfMusicSearchPrivate::tracksSimilar ( SmfTrackInfo track, int pageNum, int perPage )

   294 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   525 	{

   526 	SmfError err = SmfNoError;

   527 	//We need to pass Opcode and SmfProvider serialized into bytearray

   528 	m_serializedDataToServer.clear();

   296 	m_serializedDataToServer.clear();

   530 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   297 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   531 	write<<*m_baseProvider;

   298 	write<<*m_baseProvider;

   532 	

   299 	m_argFlag = 1;

   533 	

   300 	write<<m_argFlag;

   534 	QByteArray dataToPlugins;

   301 	write<<track;

   535 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   302 	write<<m_argFlag;

   536 	

   303 	write<<pageNum;

   537 	m_argFlag = 1;

   304 	write<<m_argFlag;

   538 	streamToPlugin<<m_argFlag;

   305 	write<<perPage;

   539 	streamToPlugin<<track;

   540 	streamToPlugin<<m_argFlag;

   541 	streamToPlugin<<pageNum;

   542 	streamToPlugin<<m_argFlag;

   543 	streamToPlugin<<perPage;

   544 	

   545 	write<<dataToPlugins;

   309 	int maxalloc = 1000;

   549 	int maxalloc = SmfMusicTracksMaxSize*perPage;

   310 	

   550 	

   311 	//call private impl's send method

   551 	//call private impl's send method

   312 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   552 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   313 			SmfMusicGetTracks, maxalloc);

   553 			SmfMusicGetTracksSimilar, maxalloc);

   314 	}

   554 	return err;

   315 

   555 	}

   316 void SmfMusicSearchPrivate::trackInfo(SmfMusicFingerPrint signature, int pageNum, int perPage)

   556 

   317 	{

   557 SmfError SmfMusicSearchPrivate::tracksOfAlbum ( SmfAlbum album, int pageNum, int perPage )

   318 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   558 	{

   559 	SmfError err = SmfNoError;

   560 	//We need to pass Opcode and SmfProvider serialized into bytearray

   561 	m_serializedDataToServer.clear();

   320 	m_serializedDataToServer.clear();

   563 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   321 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   564 	write<<*m_baseProvider;

   322 	write<<*m_baseProvider;

   565 

   323 	m_argFlag = 1;

   566 	QByteArray dataToPlugins;

   324 	write<<m_argFlag;

   567 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   325 	write<<signature;

   568 	

   326 	write<<m_argFlag;

   569 	m_argFlag = 1;

   327 	write<<pageNum;

   570 	streamToPlugin<<m_argFlag;

   328 	write<<m_argFlag;

   571 	streamToPlugin<<album;

   329 	write<<perPage;

   572 	streamToPlugin<<m_argFlag;

   330 	

   573 	streamToPlugin<<pageNum;

   574 	streamToPlugin<<m_argFlag;

   575 	streamToPlugin<<perPage;

   576 	

   577 	write<<dataToPlugins;

   578 		

   333 	int maxalloc = 1000;

   581 	int maxalloc = SmfMusicTracksMaxSize*perPage;

   582 	

   583 	//call private impl's send method

   584 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   585 			SmfMusicGetTracksOfAlbum, maxalloc);

   586 	return err;

   587 	}

   588 

   589 SmfError SmfMusicSearchPrivate::tracksOfArtist ( SmfArtists artists, int pageNum, int perPage )

   590 	{

   591 	SmfError err = SmfNoError;

   592 	//We need to pass Opcode and SmfProvider serialized into bytearray

   593 	m_serializedDataToServer.clear();

   594 	SmfProvider* m_baseProvider = m_musicSearch->getProvider();

   595 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   596 	write<<*m_baseProvider;

   597 	

   598 	QByteArray dataToPlugins;

   599 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   600 	

   601 	m_argFlag = 1;

   602 	streamToPlugin<<m_argFlag;

   603 	streamToPlugin<<artists;

   604 	streamToPlugin<<m_argFlag;

   605 	streamToPlugin<<pageNum;

   606 	streamToPlugin<<m_argFlag;

   607 	streamToPlugin<<perPage;

   608 	

   609 	write<<dataToPlugins;

   610 		

   611 	QString intfName(musicSearchInterface);

   612 	//TODO:-revisit all the maxalloc

   613 	int maxalloc = SmfMusicTracksMaxSize*perPage;

   614 	

   615 	//call private impl's send method

   616 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   617 			SmfMusicGetTracksOfArtist, maxalloc);

   618 	return err;

   619 	}

   620 

   621 SmfError SmfMusicSearchPrivate::trackInfo(SmfMusicFingerPrint signature, int pageNum, int perPage)

   622 	{

   623 	SmfError err = SmfNoError;

   624 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   625 	SmfProvider* m_baseProvider = m_musicSearch->getProvider();

   626 	m_serializedDataToServer.clear();

   627 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   628 	write<<*m_baseProvider;

   629 

   630 	QByteArray dataToPlugins;

   631 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   632 	

   633 	m_argFlag = 1;

   634 	streamToPlugin<<m_argFlag;

   635 	streamToPlugin<<signature;

   636 	streamToPlugin<<m_argFlag;

   637 	streamToPlugin<<pageNum;

   638 	streamToPlugin<<m_argFlag;

   639 	streamToPlugin<<perPage;

   640 	

   641 	write<<dataToPlugins;

   642 	

   643 	QString intfName(musicSearchInterface);

   644 	//TODO:-revisit all the maxalloc

   645 	int maxalloc = SmfMusicTracksMaxSize*perPage;

   338 	}

   650 	return err;

   339 

   651 	}

   340 void SmfMusicSearchPrivate::stores(SmfTrackInfo track, int pageNum, int perPage)

   652 

   341 	{

   653 SmfError SmfMusicSearchPrivate::stores(SmfTrackInfo track, int pageNum, int perPage)

   654 	{

   655 	SmfError err = SmfNoError;

   347 	m_argFlag = 1;

   661 

   348 	write<<m_argFlag;

   662 	QByteArray dataToPlugins;

   349 	write<<track;

   663 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   350 	write<<m_argFlag;

   664 	

   351 	write<<pageNum;

   665 	m_argFlag = 1;

   352 	write<<m_argFlag;

   666 	streamToPlugin<<m_argFlag;

   353 	write<<perPage;

   667 	streamToPlugin<<track;

   668 	streamToPlugin<<m_argFlag;

   669 	streamToPlugin<<pageNum;

   670 	streamToPlugin<<m_argFlag;

   671 	streamToPlugin<<perPage;

   672 	

   673 	write<<dataToPlugins;

   357 	int maxalloc = 1000;

   677 	int maxalloc = 1000*perPage;

   362 	}

   682 	return err;

   363 

   683 	}

   364 void SmfMusicSearchPrivate::customRequest ( const int& operationId, QByteArray* customData )

   684 

   365 	{

   685 SmfError SmfMusicSearchPrivate::customRequest ( const int& operationId, QByteArray* customData )

   686 	{

   687 	SmfError err = SmfNoError;

   371 	m_argFlag = 1;

   693 

   372 	write<<m_argFlag;

   694 	QByteArray dataToPlugins;

   373 	write<<operationId;

   695 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   374 	

   696 	

   697 	m_argFlag = 1;

   698 	streamToPlugin<<m_argFlag;

   699 	streamToPlugin<<operationId;

   377 		write<<m_argFlag;

   702 		streamToPlugin<<m_argFlag;

   378 		write<<*customData;

   703 		streamToPlugin<<*customData;

   383 		write<<m_argFlag;

   708 		streamToPlugin<<m_argFlag;

   384 		}

   709 		}

   710 	

   711 	write<<dataToPlugins;

   388 	int maxalloc = 1000;

   715 	int maxalloc = 10000;

   393 	}

   720 	return err;

   394 

   721 	}

   722 

   723 SmfError SmfMusicSearchPrivate::cancelRequest()

   724 	{

   725 	qDebug()<<"Inside SmfMusicSearchPrivate::cancelRequest()";

   726 	QByteArray notused;

   727 	QByteArray retData = m_SmfClientPrivate->sendSyncRequest(notused,SmfCancelRequest,1000, notused);

   728 	

   729 	//De-serialize it into SmfError

   730 	QDataStream reader(&retData,QIODevice::ReadOnly);

   731 	int val;

   732 	reader>>val;

   733 	SmfError error = (SmfError) val;

   734 	return error;

   735 	}

   408 		case SmfMusicGetTracks:

   749 		case SmfMusicGetTracksSimilar:

   750 		case SmfMusicGetTracksOfAlbum:

   751 		case SmfMusicGetTracksOfArtist:

   473 void SmfPlaylistServicePrivate::playlists(int pageNum, int perPage)

   816 SmfError SmfPlaylistServicePrivate::playlists(int pageNum, int perPage)

   474 	{

   817 	{

   818 	SmfError err = SmfNoError;

   480 	m_argFlag = 1;

   824 

   481 	write<<m_argFlag;

   825 	QByteArray dataToPlugins;

   482 	write<<pageNum;

   826 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   483 	write<<m_argFlag;

   827 	

   484 	write<<perPage;

   828 	m_argFlag = 1;

   829 	streamToPlugin<<m_argFlag;

   830 	streamToPlugin<<pageNum;

   831 	streamToPlugin<<m_argFlag;

   832 	streamToPlugin<<perPage;

   833 		

   834 	write<<dataToPlugins;

   488 	int maxalloc = 1000;

   838 	int maxalloc = SmfMusicPlaylistMaxSize*perPage;

   493 	}

   843 	return err;

   494 

   844 	}

   495 void SmfPlaylistServicePrivate::playlistsOf(SmfMusicProfile *user, int pageNum, int perPage)

   845 

   496 	{

   846 SmfError SmfPlaylistServicePrivate::playlistsOf(SmfContact *user, int pageNum, int perPage)

   847 	{

   848 	SmfError err = SmfNoError;

   505 		write<<m_argFlag;

   861 		streamToPlugin<<m_argFlag;

   506 		write<<*user;

   862 		streamToPlugin<<*user;

   511 		write<<m_argFlag;

   867 		streamToPlugin<<m_argFlag;

   512 		}

   868 		}

   513 	m_argFlag = 1;

   869 	m_argFlag = 1;

   514 	write<<m_argFlag;

   870 	streamToPlugin<<m_argFlag;

   515 	write<<pageNum;

   871 	streamToPlugin<<pageNum;

   516 	write<<m_argFlag;

   872 	streamToPlugin<<m_argFlag;

   517 	write<<perPage;

   873 	streamToPlugin<<perPage;

   874 		

   875 	write<<dataToPlugins;

   521 	int maxalloc = 1000;

   879 	int maxalloc = SmfMusicPlaylistMaxSize*perPage;

   526 	}

   884 	return err;

   527 

   885 	}

   528 int SmfPlaylistServicePrivate::addToPlaylist(SmfPlaylist plst, SmfTrackInfoList *tracks)

   886 

   529 	{

   887 SmfError SmfPlaylistServicePrivate::addToPlaylist(SmfPlaylist plst, SmfTrackInfoList *tracks)

   888 	{

   889 	SmfError err = SmfNoError;

   535 	m_argFlag = 1;

   895 	

   536 	write<<m_argFlag;

   896 	QByteArray dataToPlugins;

   537 	write<<plst;

   897 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   898 	

   899 	m_argFlag = 1;

   900 	streamToPlugin<<m_argFlag;

   901 	streamToPlugin<<plst;

   540 		write<<m_argFlag;

   904 		streamToPlugin<<m_argFlag;

   541 		write<<*tracks;

   905 		streamToPlugin<<*tracks;

   546 		write<<m_argFlag;

   910 		streamToPlugin<<m_argFlag;

   547 		}

   911 		}

   912 		

   913 	write<<dataToPlugins;

   554 	return m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   920 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   556 	}

   922 	return err;

   557 

   923 	}

   558 int SmfPlaylistServicePrivate::postCurrentPlayingPlaylist(SmfPlaylist plst)

   924 

   559 	{

   925 SmfError SmfPlaylistServicePrivate::postCurrentPlayingPlaylist(SmfPlaylist plst)

   926 	{

   927 	SmfError err = SmfNoError;

   565 	m_argFlag = 1;

   933 	

   566 	write<<m_argFlag;

   934 	QByteArray dataToPlugins;

   567 	write<<plst;

   935 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   936 	

   937 	m_argFlag = 1;

   938 	streamToPlugin<<m_argFlag;

   939 	streamToPlugin<<plst;

   940 		

   941 	write<<dataToPlugins;

   574 	return m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   948 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   576 	}

   950 	return err;

   577 

   951 	}

   578 void SmfPlaylistServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

   952 

   579 	{

   953 SmfError SmfPlaylistServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

   954 	{

   955 	SmfError err = SmfNoError;

   585 	m_argFlag = 1;

   961 

   586 	write<<m_argFlag;

   962 	QByteArray dataToPlugins;

   587 	write<<operationId;

   963 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   588 	

   964 	

   965 	m_argFlag = 1;

   966 	streamToPlugin<<m_argFlag;

   967 	streamToPlugin<<operationId;

   591 		write<<m_argFlag;

   970 		streamToPlugin<<m_argFlag;

   592 		write<<*customData;

   971 		streamToPlugin<<*customData;

   597 		write<<m_argFlag;

   976 		streamToPlugin<<m_argFlag;

   598 		}

   977 		}

   978 	

   979 	write<<dataToPlugins;

   602 	int maxalloc = 1000;

   983 	int maxalloc = 10000;

   657 //SmfMusicEventsPrivate start

  1053 

   658 SmfMusicEventsPrivate::SmfMusicEventsPrivate(SmfMusicEvents *aMusicEvent)

  1054 //SmfLyricsServicePrivate start

   659 		:m_musicEvent(aMusicEvent)

  1055 SmfLyricsServicePrivate::SmfLyricsServicePrivate(SmfLyricsService *aLyricsSrvc)

  1056 		: m_lyricsSrvc(aLyricsSrvc)

   669 SmfMusicEventsPrivate::~SmfMusicEventsPrivate()

  1066 SmfLyricsServicePrivate::~SmfLyricsServicePrivate()

   678 void SmfMusicEventsPrivate::events(SmfLocation venue, int pageNum, int perPage)

  1075 SmfError SmfLyricsServicePrivate::lyrics(SmfTrackInfo track, int pageNum, int perPage)

   679 	{

  1076 	{

   680 	//We need to pass Opcode and SmfProvider serialized into bytearray 

  1077 	SmfError err = SmfNoError;

   681 	SmfProvider* m_baseProvider = m_musicEvent->getProvider();

  1078 	//We need to pass Opcode and SmfProvider serialized into bytearray 

  1079 	SmfProvider* m_baseProvider = m_lyricsSrvc->getProvider();

   685 	m_argFlag = 1;

  1083 

   686 	write<<m_argFlag;

  1084 	QByteArray dataToPlugins;

   687 	write<<venue;

  1085 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   688 	write<<m_argFlag;

  1086 	

   689 	write<<pageNum;

  1087 	m_argFlag = 1;

   690 	write<<m_argFlag;

  1088 	streamToPlugin<<m_argFlag;

   691 	write<<perPage;

  1089 	streamToPlugin<<track;

   692 		

  1090 	streamToPlugin<<m_argFlag;

   693 	QString intfName(musicEventServiceInterface);

  1091 	streamToPlugin<<pageNum;

   694 	//TODO:-revisit all the maxalloc

  1092 	streamToPlugin<<m_argFlag;

   695 	int maxalloc = 1000;

  1093 	streamToPlugin<<perPage;

   696 	

  1094 	

   697 	//call private impl's send method

  1095 	write<<dataToPlugins;

   698 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   699 			SmfMusicGetEventsOnLoc, maxalloc);

   700 	}

   701 

   702 void SmfMusicEventsPrivate::venues(SmfLocation location, int pageNum, int perPage)

   703 	{

   704 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   705 	SmfProvider* m_baseProvider = m_musicEvent->getProvider();

   706 	m_serializedDataToServer.clear();

   707 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   708 	write<<*(m_baseProvider);

   709 	m_argFlag = 1;

   710 	write<<m_argFlag;

   711 	write<<location;

   712 	write<<m_argFlag;

   713 	write<<pageNum;

   714 	write<<m_argFlag;

   715 	write<<perPage;

   716 		

   717 	QString intfName(musicEventServiceInterface);

   718 	//TODO:-revisit all the maxalloc

   719 	int maxalloc = 1000;

   720 	

   721 	//call private impl's send method

   722 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   723 			SmfMusicGetVenueOnLoc, maxalloc);

   724 	}

   725 

   726 void SmfMusicEventsPrivate::postEvents(SmfEventList events)

   727 	{

   728 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   729 	SmfProvider* m_baseProvider = m_musicEvent->getProvider();

   730 	m_serializedDataToServer.clear();

   731 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   732 	write<<*(m_baseProvider);

   733 	m_argFlag = 1;

   734 	write<<m_argFlag;

   735 	write<<events;

   736 	

   737 	QString intfName(musicEventServiceInterface);

   738 	//TODO:-revisit all the maxalloc

   739 	int maxalloc = 1000;

   740 	

   741 	//call private impl's send method

   742 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   743 			SmfMusicPostEvents, maxalloc);

   744 	}

   745 

   746 void SmfMusicEventsPrivate::customRequest ( const int& operationId, QByteArray* customData )

   747 	{

   748 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   749 	SmfProvider* m_baseProvider = m_musicEvent->getProvider();

   750 	m_serializedDataToServer.clear();

   751 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   752 	write<<*m_baseProvider;

   753 	m_argFlag = 1;

   754 	write<<m_argFlag;

   755 	write<<operationId;

   756 	

   757 	if(customData)

   758 		{

   759 		write<<m_argFlag;

   760 		write<<*customData;

   761 		}

   762 	else

   763 		{

   764 		m_argFlag = 0;

   765 		write<<m_argFlag;

   766 		}

   767 	

   768 	QString intfName(musicEventServiceInterface);

   769 	//TODO:-revisit all the maxalloc

   770 	int maxalloc = 1000;

   771 	

   772 	//call private impl's send method

   773 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,

   774 			SmfMusicEventsCustomRequest, maxalloc);

   775 	}

   776 

   777 void SmfMusicEventsPrivate::resultsAvailable(QByteArray result,SmfRequestTypeID opcode,SmfError error)

   778 	{

   779 	//note:- "result" is serialized and we need to de-serialize it as per opcode

   780 	//Order of serialization Error value followed by data

   781 	

   782 	QDataStream reader(&result,QIODevice::ReadOnly);

   783 	

   784 	//Now de-serialize it based on opcode

   785 	switch(opcode)

   786 		{

   787 		case SmfMusicGetEventsOnLoc:

   788 			{

   789 			SmfEventList* m_events = new SmfEventList;

   790 			reader>>*(m_events);

   791 			

   792 			// ToDo :-

   793 			SmfResultPage page;

   794 			

   795 			m_musicEvent->eventsAvailable(m_events,error,page);

   796 			break;

   797 			}

   798 			

   799 		case SmfMusicGetVenueOnLoc:

   800 			{

   801 			SmfLocationList* m_venues = new SmfLocationList;

   802 			reader>>*(m_venues);

   803 			

   804 			//ToDo :-

   805 			SmfResultPage page;

   806 			

   807 			m_musicEvent->venuesAvailable(m_venues,error,page);

   808 			break;

   809 			}

   810 			

   811 		case SmfMusicPostEvents:

   812 			m_musicEvent->eventsUpdated(error);

   813 			break;

   814 			

   815 		case SmfMusicEventsCustomRequest:

   816    			{

   817    			int operationId;

   818    			QByteArray *data = new QByteArray;

   819    			reader>>operationId;

   820    			reader>>*data;

   821    			qDebug()<<"operationId = "<<operationId;

   822    			qDebug()<<"data size = "<<data->size();

   823    			emit m_musicEvent->customDataAvailable(operationId, data);

   824    			break;

   825    			}

   826    			

   827 		default:

   828 			Q_ASSERT_X(1,"SmfMusicEventsPrivate::resultsAvailable","unknown opcode");

   829 		}

   830 	}

   831 //SmfMusicEventsPrivate end

   832 

   833 

   834 //SmfLyricsServicePrivate start

   835 SmfLyricsServicePrivate::SmfLyricsServicePrivate(SmfLyricsService *aLyricsSrvc)

   836 		: m_lyricsSrvc(aLyricsSrvc)

   837 	{

   838 #ifdef Q_OS_SYMBIAN

   839 	//private impl for symbian

   840 	m_SmfClientPrivate = CSmfClientSymbian::NewL(this);

   841 #else

   842 	//TODO:- Use private impl for other platforms or else Qt impl

   843 #endif

   844 	}

   845 

   846 SmfLyricsServicePrivate::~SmfLyricsServicePrivate()

   847 	{

   848 	if(m_SmfClientPrivate)

   849 		{

   850 		delete m_SmfClientPrivate;

   851 		m_SmfClientPrivate = NULL;

   852 		}

   853 	}

   854 

   855 void SmfLyricsServicePrivate::lyrics(SmfTrackInfo track, int pageNum, int perPage)

   856 	{

   857 	//We need to pass Opcode and SmfProvider serialized into bytearray 

   858 	SmfProvider* m_baseProvider = m_lyricsSrvc->getProvider();

   859 	m_serializedDataToServer.clear();

   860 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);

   861 	write<<*(m_baseProvider);

   862 	m_argFlag = 1;

   863 	write<<m_argFlag;

   864 	write<<track;

   865 	write<<m_argFlag;

   866 	write<<pageNum;

   867 	write<<m_argFlag;

   868 	write<<perPage;

   872 	int maxalloc = 1000;

  1099 	int maxalloc = SmfMusicLyricsMaxSize*perPage;

   877 	}

  1104 	return err;

   878 

  1105 	}

   879 void SmfLyricsServicePrivate::subtitles(SmfTrackInfo track, SmfSubtitleSearchFilter filter, 

  1106 

  1107 SmfError SmfLyricsServicePrivate::subtitles(SmfTrackInfo track, SmfSubtitleSearchFilter filter, 

   886 	m_argFlag = 1;

  1115 

   887 	write<<m_argFlag;

  1116 	QByteArray dataToPlugins;

   888 	write<<track;

  1117 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   889 	write<<m_argFlag;

  1118 	

   890 	write<<filter;

  1119 	m_argFlag = 1;

   891 	write<<m_argFlag;

  1120 	streamToPlugin<<m_argFlag;

   892 	write<<pageNum;

  1121 	streamToPlugin<<track;

   893 	write<<m_argFlag;

  1122 	streamToPlugin<<m_argFlag;

   894 	write<<perPage;

  1123 	streamToPlugin<<filter;

  1124 	streamToPlugin<<m_argFlag;

  1125 	streamToPlugin<<pageNum;

  1126 	streamToPlugin<<m_argFlag;

  1127 	streamToPlugin<<perPage;

  1128 	

  1129 	write<<dataToPlugins;

   898 	int maxalloc = 1000;

  1133 	int maxalloc = SmfMusicLyricsMaxSize*perPage;

   903 	}

  1138 	return err;

   904 

  1139 	}

   905 void SmfLyricsServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

  1140 

   906 	{

  1141 SmfError SmfLyricsServicePrivate::customRequest ( const int& operationId, QByteArray* customData )

  1142 	{

  1143 	SmfError err = SmfNoError;

   912 	m_argFlag = 1;

  1149 

   913 	write<<m_argFlag;

  1150 	QByteArray dataToPlugins;

   914 	write<<operationId;

  1151 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);

   915 	

  1152 	

  1153 	m_argFlag = 1;

  1154 	streamToPlugin<<m_argFlag;

  1155 	streamToPlugin<<operationId;

   918 		write<<m_argFlag;

  1158 		streamToPlugin<<m_argFlag;

   919 		write<<*customData;

  1159 		streamToPlugin<<*customData;