1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 #include <utility>

    20 #include <algorithm>

    21 #include "pushdatacontainer.h"

    22 #include "comms.h"

    23 #include "logger.h"

    24 #include "javacommonutils.h"

    25 #include "pushdbhandler.h"

    26 #include "pushexception.h"

    27 #include "pusherrorcodes.h"

    28 #include "javauid.h"

    29 #include "javastoragenames.h"

    30 

    31 using namespace java::push;

    32 using namespace java::captain;

    33 using namespace java::comms;

    34 using namespace java::storage;

    35 using namespace java::util;

    36 

    37 /**

    38  *

    39  */

    40 PushDataContainer::PushDataContainer(java::captain::CoreInterface& aCore,

    41                                      PushDBHandler& aDbHandler)

    42         : mCore(aCore),mPushDbHandler(aDbHandler),mPushRegsLoaded(false)

    43 {

    44     JELOG2(EJavaPush);

    45 }

    46 

    47 /**

    48  *

    49  */

    50 PushDataContainer::~PushDataContainer()

    51 {

    52     JELOG2(EJavaPush);

    53     mPushRegistrations.clear();

    54     mDoNotLaunchList.clear();

    55     mMidletSuiteInfo.clear();

    56 }

    57 

    58 /**

    59  *

    60  */

    61 void PushDataContainer::getIdsOfMidlets(std::set<Uid>& aUidList)

    62 {

    63     JELOG2(EJavaPush);

    64     //Retrieving all push registrations from the db.

    65     loadPushRegs();

    66 

    67     PushRegsContainerIter_t iter;

    68     for (iter = mPushRegistrations.begin(); iter != mPushRegistrations.end(); ++iter)

    69     {

    70         aUidList.insert(iter->first);

    71     }//end for

    72 }

    73 

    74 /**

    75  *

    76  */

    77 bool PushDataContainer::isPushConnections(const Uid& aUid)

    78 {

    79     JELOG2(EJavaPush);

    80     loadPushRegs();

    81 

    82     std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

    83     pushRegsOfMidletIter = mPushRegistrations.equal_range(aUid);

    84     if (pushRegsOfMidletIter.first == pushRegsOfMidletIter.second)

    85         return false;

    86 

    87     return true;

    88 }

    89 

    90 /**

    91  *

    92  */

    93 void PushDataContainer::storeDynamicPushRegistration(const Uid& aUid,const std::wstring& aUri,

    94         const std::wstring& aMidletName,

    95         const std::wstring& aFilter)

    96 {

    97     JELOG2(EJavaPush);

    98     loadPushRegs();

    99 

   100     if (true == pushRegExists(aUri))

   101     {

   102         throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,"Push connection already exists",

   103                             __FILE__,__FUNCTION__,__LINE__);

   104     }

   105 

   106     mPushDbHandler.storeDynamicPushRegistration(aUid,aUri,aMidletName,aFilter);

   107 

   108     PushRegistrationData data(aUri,aMidletName,aFilter,PushRegistrationData::DYNAMIC_REG);

   109     mPushRegistrations.insert(std::pair<Uid,PushRegistrationData>(aUid,data));

   110     //This situation MIDlet must be also removed from "do not launch" list.

   111     mDoNotLaunchList.erase(aUid);

   112 }

   113 

   114 /**

   115  *

   116  */

   117 void PushDataContainer::unregisterDynamicPushRegistration(const Uid& aUid,const std::wstring& aUri)

   118 {

   119     JELOG2(EJavaPush);

   120     loadPushRegs();

   121 

   122     //Deleting push reg from the storage. It has been checked in the java side that

   123     //type of the push reg is dynamic and it belongs to one MIDlet in the MIDlet suite.

   124     mPushDbHandler.unregisterDynamicPushRegistration(aUid,aUri);

   125 

   126     //Deleting push registration from the cache.

   127     std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

   128     pushRegsOfMidletIter = mPushRegistrations.equal_range(aUid);

   129     PushRegsContainerIter_t iter;

   130     for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

   131     {

   132         if (0 == aUri.compare(iter->second.mUri))

   133         {

   134             mPushRegistrations.erase(iter);

   135             break;

   136         }

   137     }//end for

   138 

   139     //This situation MIDlet must be also removed from "do not launch" list.

   140     mDoNotLaunchList.erase(aUid);

   141 }

   142 

   143 /**

   144  *

   145  */

   146 void PushDataContainer::setMidletDoNotLaunchList(const Uid& aUid)

   147 {

   148     JELOG2(EJavaPush);

   149     mDoNotLaunchList.insert(aUid);

   150 }

   151 

   152 /**

   153  *

   154  */

   155 void PushDataContainer::removeMidletFromDoNotLaunchList(const Uid& aMidletUid)

   156 {

   157     JELOG2(EJavaPush);

   158     mDoNotLaunchList.erase(aMidletUid);

   159 }

   160 

   161 /**

   162  *

   163  */

   164 bool PushDataContainer::isMidletInDoNotLaunchList(const Uid& aUid)

   165 {

   166     JELOG2(EJavaPush);

   167     if (0 == mDoNotLaunchList.size())

   168         return false;

   169     DoNotLaunchListIter_t iter = mDoNotLaunchList.find(aUid);

   170     if (mDoNotLaunchList.end() != iter)

   171         return true;

   172     return false;

   173 }

   174 

   175 /**

   176  *

   177  */

   178 void PushDataContainer::removeApp(const Uid& aMidletUid)

   179 {

   180     JELOG2(EJavaPush);

   181 

   182     mPushRegistrations.erase(aMidletUid);

   183     removeMidletFromDoNotLaunchList(aMidletUid);

   184 

   185     MidletSuiteInfoContainerIter_t iter;

   186     for (iter = mMidletSuiteInfo.begin(); iter != mMidletSuiteInfo.end();)

   187     {

   188         if (aMidletUid == iter->second.mMidletUid)

   189         {

   190             mMidletSuiteInfo.erase(iter++);

   191             break;

   192         }

   193         else

   194         {

   195             ++iter;

   196         }

   197     }//end for

   198 }

   199 

   200 /**

   201  *

   202  */

   203 void PushDataContainer::readAppDataFromDb(const Uid& aUid)

   204 {

   205     JELOG2(EJavaPush);

   206     try

   207     {

   208         loadPushRegs();

   209         readPushRegs(aUid);

   210         mPushDbHandler.getMidletSuiteInfoByMidletUid(aUid,mMidletSuiteInfo);

   211         mDoNotLaunchList.erase(aUid);

   212     }

   213     catch (...)

   214     {

   215         ELOG(EJavaPush,"ERROR!!! Exception caught in the PushDataContainer::readAppDataFromDb() operation");

   216     }

   217 }

   218 

   219 /**

   220  *

   221  */

   222 void PushDataContainer::setPendingStatusOfConn(const Uid& aUid,const std::wstring& aUri,

   223         bool aMsgWaitsHandling)

   224 {

   225     JELOG2(EJavaPush);

   226 

   227     LOG1(EJavaPush,EInfo,"aMsgWaitsHandling: %d",(int)aMsgWaitsHandling);

   228 

   229     PushRegistrationData* dataObj = getPushDataByMidletUidAndUri(aUid,aUri);

   230     dataObj->mPendingStatus = aMsgWaitsHandling;

   231 }

   232 

   233 /**

   234  *

   235  */

   236 void PushDataContainer::clearPendingStatusesOfMidlet(const java::util::Uid& aMidletUid)

   237 {

   238     JELOG2(EJavaPush);

   239 

   240     std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

   241     pushRegsOfMidletIter = mPushRegistrations.equal_range(aMidletUid);

   242     PushRegsContainerIter_t iter;

   243     for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

   244     {

   245         iter->second.mPendingStatus = false;

   246     }

   247 }

   248 

   249 /**

   250  *

   251  */

   252 void PushDataContainer::getPushRegsOfMidletSuite(const Uid& aMidletSuiteUid,

   253         bool aAllConnsFlag,

   254         std::list<std::wstring>& aListOfPushUris)

   255 {

   256     JELOG2(EJavaPush);

   257 

   258     LOG1WSTR(EJavaPush,EInfo,"getPushRegsOfMidletSuite(): Value of the suite UID: %s",

   259              aMidletSuiteUid.toString());

   260     LOG1(EJavaPush,EInfo,"aAllConnsFlag: %d",(int)aAllConnsFlag);

   261 

   262     std::pair<MidletSuiteInfoContainerIter_t,MidletSuiteInfoContainerIter_t> suiteInfoIter;

   263     suiteInfoIter = mMidletSuiteInfo.equal_range(aMidletSuiteUid);

   264     MidletSuiteInfoContainerIter_t iter;

   265     for (iter = suiteInfoIter.first; iter != suiteInfoIter.second; ++iter)

   266     {

   267         fillConnectionsOfMidlet(iter->second.mMidletUid,aAllConnsFlag,aListOfPushUris);

   268     }//end  for

   269 }

   270 

   271 /**

   272  *

   273  */

   274 const std::wstring& PushDataContainer::getFilterOfPushConn(const Uid& aSuiteUid,

   275         const std::wstring& aUri)

   276 {

   277     JELOG2(EJavaPush);

   278 

   279     PushRegistrationData* dataObj = getPushConnOfSuite(aSuiteUid,aUri);

   280     return dataObj->mFilter;

   281 }

   282 

   283 /**

   284  *

   285  */

   286 const std::wstring& PushDataContainer::getClassNameOfPushConn(const Uid& aSuiteUid,

   287         const std::wstring& aUri)

   288 {

   289     JELOG2(EJavaPush);

   290 

   291     PushRegistrationData* dataObj = getPushConnOfSuite(aSuiteUid,aUri);

   292     return dataObj->mMidletClass;

   293 }

   294 

   295 /**

   296  *

   297  */

   298 const Uid& PushDataContainer::getMidletUid(const Uid& aSuiteUid,

   299         const std::wstring& aClassName)

   300 {

   301     JELOG2(EJavaPush);

   302 

   303     std::pair<MidletSuiteInfoContainerIter_t,MidletSuiteInfoContainerIter_t> suiteInfoIter;

   304     suiteInfoIter = mMidletSuiteInfo.equal_range(aSuiteUid);

   305     MidletSuiteInfoContainerIter_t iter;

   306     for (iter = suiteInfoIter.first; iter != suiteInfoIter.second; ++iter)

   307     {

   308         if (iter->second.mMidletClassName == aClassName)

   309         {

   310             return iter->second.mMidletUid;

   311         }

   312     }//end  for

   313     throw PushException(INCORRECT_APP_DATA,

   314                         "Class name does not match to any MIDlet in the suite",

   315                         __FILE__,__FUNCTION__,__LINE__);

   316 }

   317 

   318 /**

   319  *

   320  */

   321 bool PushDataContainer::getSuiteUidByBaseUri(const std::wstring& aBaseUri,

   322         Uid& aOutputSuiteUid)

   323 {

   324     JELOG2(EJavaPush);

   325 

   326     PushRegsContainerIter_t iter;

   327     std::string aBaseUriStr(aBaseUri.begin(),aBaseUri.end());

   328     for (iter = mPushRegistrations.begin(); iter != mPushRegistrations.end(); ++iter)

   329     {

   330         //size_t found = iter->second.mUri.find(aBaseUri);

   331         //if(0 == found)

   332         std::string fullUriStr(iter->second.mUri.begin(),iter->second.mUri.end());

   333         bool matchFlag = isUriStartingWith(fullUriStr,aBaseUriStr);

   334         if (true == matchFlag)

   335         {

   336             return getSuiteUidByMidletUid(iter->first,aOutputSuiteUid);

   337         }

   338     }//end for

   339 

   340     return false;

   341 }

   342 

   343 /**

   344  *

   345  */

   346 int PushDataContainer::getMediaIdByMidletUid(const Uid& aMidletUid)

   347 {

   348     JELOG2(EJavaPush);

   349 

   350     MidletSuiteInfoContainerIter_t iter;

   351     for (iter = mMidletSuiteInfo.begin(); iter != mMidletSuiteInfo.end(); ++iter)

   352     {

   353         if (aMidletUid == iter->second.mMidletUid)

   354         {

   355             return iter->second.mMediaId;

   356         }

   357     }

   358     return UNDEFINED_MEDIA_ID;

   359 }

   360 

   361 /**

   362  *

   363  */

   364 void PushDataContainer::getMidletUidsByMediaId(unsigned int aMediaId,std::list<Uid>& aUidList)

   365 {

   366     JELOG2(EJavaPush);

   367 

   368     MidletSuiteInfoContainerIter_t iter;

   369     for (iter = mMidletSuiteInfo.begin(); iter != mMidletSuiteInfo.end(); ++iter)

   370     {

   371         if (aMediaId == iter->second.mMediaId)

   372             aUidList.push_back(iter->second.mMidletUid);

   373     }

   374 }

   375 

   376 /**

   377  *

   378  */

   379 void PushDataContainer::loadPushRegs()

   380 {

   381     JELOG2(EJavaPush);

   382 

   383     if (true == mPushRegsLoaded)

   384         return;

   385 

   386     //Empty uid means that all push registrations are read from the db.

   387     java::util::Uid emptyUid;

   388     readPushRegs(emptyUid);

   389     //readMidletSuiteInfo(emptyUid);

   390     mPushDbHandler.getMidletSuiteInfo(emptyUid,mMidletSuiteInfo);

   391 

   392     mPushRegsLoaded = true;

   393 }

   394 

   395 /**

   396  *

   397  */

   398 void PushDataContainer::readPushRegs(const java::util::Uid& aUid)

   399 {

   400     JELOG2(EJavaPush);

   401 

   402     LOG1WSTR(EJavaPush,EInfo,"readPushRegs() Uid: %s",aUid.toString());

   403 

   404     JavaStorageApplicationList_t pushRegs;

   405     mPushDbHandler.getPushRegs(aUid,pushRegs);

   406 

   407     JavaStorageApplicationList_t::iterator iter;

   408     for (iter = pushRegs.begin(); iter != pushRegs.end(); ++iter)

   409     {

   410         insertPushRegToInternalContainer(iter);

   411     }//end for

   412 }

   413 

   414 /**

   415  *

   416  */

   417 void PushDataContainer::insertPushRegToInternalContainer

   418 (JavaStorageApplicationList_t::iterator& aIter)

   419 {

   420     JavaStorageApplicationEntry_t::iterator multisetIter;

   421     Uid uid;

   422     std::wstring uri;

   423     std::wstring midletClass;

   424     std::wstring filter;

   425     PushRegistrationData::RegistrationType_t regType = PushRegistrationData::DYNAMIC_REG;

   426     int counter = 0;

   427     for (multisetIter = aIter->begin(); multisetIter != aIter->end(); ++multisetIter)

   428     {

   429         try

   430         {

   431             if (0 == multisetIter->entryName().compare(ID))

   432             {

   433                 Uid tmpUid(multisetIter->entryValue());

   434                 uid = tmpUid;

   435                 counter++;

   436             }

   437             else if (0 == multisetIter->entryName().compare(URL))

   438             {

   439                 uri = multisetIter->entryValue();

   440                 counter++;

   441             }

   442             else if (0 == multisetIter->entryName().compare(NAME))

   443             {

   444                 midletClass = multisetIter->entryValue();

   445                 counter++;

   446             }

   447             else if (0 == multisetIter->entryName().compare(FILTER))

   448             {

   449                 filter = multisetIter->entryValue();

   450                 counter++;

   451             }

   452             else if (0 == multisetIter->entryName().compare(REGISTRATION_TYPE))

   453             {

   454                 int tmpInt = JavaCommonUtils::wstringToInt(multisetIter->entryValue());

   455                 if ((tmpInt == PushRegistrationData::DYNAMIC_REG)

   456                         || (tmpInt == PushRegistrationData::STATIC_REG))

   457                 {

   458                     regType = (PushRegistrationData::RegistrationType_t) tmpInt;

   459                     counter++;

   460                 }

   461             }

   462             if (5 == counter)

   463             {

   464                 //All arguments reads successfully.

   465                 PushRegistrationData data(uri,midletClass,filter,regType);

   466                 mPushRegistrations.insert(std::pair<Uid,PushRegistrationData>(uid,data));

   467                 counter = 0;

   468             }

   469             else if (5 > counter)

   470             {

   471                 continue;

   472             }

   473             else

   474             {

   475                 ELOG1(EJavaPush,"ERROR!!! All arguments wasn''t read successfully: %d",counter);

   476                 counter = 0;

   477             }

   478         }

   479         catch (...)

   480         {

   481             ELOG(EJavaPush,"ERROR!!! Exception caught in the reading push regs");

   482         }

   483     }//end for

   484 }

   485 

   486 /**

   487  *

   488  */

   489 void PushDataContainer::getPushRegsOfMidlet(const Uid& aUid,std::list<PushRegData>& aOutputList)

   490 {

   491     JELOG2(EJavaPush);

   492 

   493     loadPushRegs();

   494 

   495     std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

   496     pushRegsOfMidletIter = mPushRegistrations.equal_range(aUid);

   497     PushRegsContainerIter_t iter;

   498     for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

   499     {

   500         PushRegData pushData(iter->second.mUri,iter->second.mFilter);

   501         aOutputList.push_back(pushData);

   502     }//end for

   503 }

   504 

   505 /**

   506  *

   507  */

   508 bool PushDataContainer::pushRegExists(const std::wstring& aUri)

   509 {

   510     JELOG2(EJavaPush);

   511 

   512     for (PushRegsContainerIter_t iter = mPushRegistrations.begin();

   513             iter != mPushRegistrations.end(); ++iter)

   514     {

   515         if (0 == aUri.compare(iter->second.mUri))

   516             return true;

   517     }

   518     return false;

   519 }

   520 

   521 /**

   522  *

   523  */

   524 void PushDataContainer::fillConnectionsOfMidlet(const java::util::Uid& aMidletUid,

   525         bool aAllConnsFlag,

   526         std::list<std::wstring>& aListOfPushUris)

   527 {

   528     std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

   529     pushRegsOfMidletIter = mPushRegistrations.equal_range(aMidletUid);

   530     PushRegsContainerIter_t iter;

   531     for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

   532     {

   533         if (false == aAllConnsFlag)

   534         {

   535             //Connection is skipped if it is not in the pending state.

   536             if (false == iter->second.mPendingStatus)

   537                 continue;

   538         }

   539         aListOfPushUris.push_back(iter->second.mUri);

   540     }//end for

   541 }

   542 

   543 /**

   544  *

   545  */

   546 bool PushDataContainer::isMidletPartOfSuite(const Uid& aSuiteUid,const Uid& aMidletUid)

   547 {

   548     JELOG2(EJavaPush);

   549 

   550     std::pair<MidletSuiteInfoContainerIter_t,MidletSuiteInfoContainerIter_t> suiteInfoIter;

   551     suiteInfoIter = mMidletSuiteInfo.equal_range(aSuiteUid);

   552     MidletSuiteInfoContainerIter_t iter;

   553     bool midletFound = false;

   554     for (iter = suiteInfoIter.first; iter != suiteInfoIter.second; ++iter)

   555     {

   556         if (iter->second.mMidletUid == aMidletUid)

   557         {

   558             midletFound = true;

   559             break;

   560         }

   561     }//end  for

   562     return midletFound;

   563 }

   564 

   565 /**

   566  *

   567  */

   568 PushRegistrationData* PushDataContainer::getPushConnOfSuite(const Uid& aSuiteUid,

   569         const std::wstring& aUri)

   570 {

   571     JELOG2(EJavaPush);

   572 

   573     PushRegistrationDataWithUid dataObj = getPushDataByUri(aUri);

   574     if (0 == dataObj.mPushRegData)

   575     {

   576         throw PushException(SRV_CONN_NOT_FOUND,"MIDlet does not have push connection by given URI",

   577                             __FILE__,__FUNCTION__,__LINE__);

   578     }

   579 

   580     bool midletFound = isMidletPartOfSuite(aSuiteUid,dataObj.mUid);

   581     if (false == midletFound)

   582     {

   583         throw PushException(SRV_CONN_NOT_FOUND,"MIDlet does not belong to given MIDlet suite",

   584                             __FILE__,__FUNCTION__,__LINE__);

   585     }

   586     return dataObj.mPushRegData;

   587 }

   588 

   589 /**

   590  *

   591  */

   592 PushRegistrationData*

   593 PushDataContainer::getPushDataByMidletUidAndUri(const Uid& aMidletUid,

   594         const std::wstring& aUri)

   595 {

   596     JELOG2(EJavaPush);

   597 

   598     LOG1WSTR(EJavaPush,EInfo,"getPushDataByMidletUidAndUri() URI: %s",aUri);

   599 

   600     std::pair<PushRegsContainerIter_t,PushRegsContainerIter_t> pushRegsOfMidletIter;

   601     pushRegsOfMidletIter = mPushRegistrations.equal_range(aMidletUid);

   602     PushRegsContainerIter_t iter;

   603     for (iter = pushRegsOfMidletIter.first; iter != pushRegsOfMidletIter.second; ++iter)

   604     {

   605         if (aUri == iter->second.mUri)

   606             return &iter->second;

   607     }

   608     return 0;

   609 }

   610 

   611 /**

   612  *

   613  */

   614 PushRegistrationDataWithUid PushDataContainer::getPushDataByUri(const std::wstring& aUri)

   615 {

   616     JELOG2(EJavaPush);

   617 

   618     PushRegsContainerIter_t iter;

   619     for (iter = mPushRegistrations.begin(); iter != mPushRegistrations.end(); ++iter)

   620     {

   621         if (aUri == iter->second.mUri)

   622             return PushRegistrationDataWithUid(iter->first,&iter->second);

   623     }//end for

   624     Uid emptyUid;

   625     return PushRegistrationDataWithUid(emptyUid,0);

   626 }

   627 

   628 /**

   629  *

   630  */

   631 bool PushDataContainer::getSuiteUidByMidletUid(const java::util::Uid& aMidletUid,

   632         java::util::Uid& aOutputSuiteUid)

   633 {

   634     JELOG2(EJavaPush);

   635 

   636     MidletSuiteInfoContainerIter_t iter;

   637     for (iter = mMidletSuiteInfo.begin(); iter != mMidletSuiteInfo.end(); ++iter)

   638     {

   639         if (aMidletUid == iter->second.mMidletUid)

   640         {

   641             aOutputSuiteUid = iter->first;

   642             return true;

   643         }

   644     }

   645     return false;

   646 }

   647 

   648 /**

   649  *

   650  */

   651 bool PushDataContainer::isUriStartingWith(const std::string& aFullUri,

   652         const std::string& aBaseUri)

   653 {

   654     if (aBaseUri.size() > aFullUri.size())

   655         return false;

   656     std::string::const_iterator iter = std::search(aFullUri.begin(),aFullUri.end(),

   657                                        aBaseUri.begin(),aBaseUri.end(),

   658                                        caseInsensitiveCompare);

   659     if (aFullUri.end() == iter)

   660         return false;

   661     if (0 == (iter - aFullUri.begin()))

   662         return true;

   663     return false;

   664 }

   665 

   666 /**

   667  *

   668  */

   669 bool PushDataContainer::caseInsensitiveCompare(const char a1,const char a2)

   670 {

   671     return toupper(a1) == toupper(a2);

   672 }

   673 

   674