Mercurial Mercurial > oss > FCL > sf > mw > homescreensrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
activityfw/activityserviceplugin/s60/src/afstorageproxy_p.cpp
changeset 116 305818acdca4
parent 107 b34d53f6acdf
child 119 50e220be30d1
equal deleted inserted replaced
112:dbfb5e38438b 116:305818acdca4 
    31 #include "afstorageproxy.h"
 
    31 #include "afstorageproxy.h"
 
    32 #include "afserializer.h"
 
    32 #include "afserializer.h"
 
    33 
    33 
    34 AfStorageProxyPrivate::AfStorageProxyPrivate(AfStorageProxy *q) : mClient(0), q_ptr(q)
 
    34 AfStorageProxyPrivate::AfStorageProxyPrivate(AfStorageProxy *q) : mClient(0), q_ptr(q)
 
    35 {    
    35 {    
    36     QT_TRAP_THROWING(mClient = CAfStorageClient::NewL(*this));
 
    36     QT_TRAP_THROWING(
 
       
    37         mClient = CAfStorageClient::NewL(*this);
 
       
    38         User::LeaveIfError(mAppArcSession.Connect());
 
       
    39     );
 
    37 }
 
    40 }
 
    38 
    41 
    39 AfStorageProxyPrivate::~AfStorageProxyPrivate()
 
    42 AfStorageProxyPrivate::~AfStorageProxyPrivate()
 
    40 {
 
    43 {
 
    41     delete mClient;
 
    44     delete mClient;
 
    42 }
 
    45     mAppArcSession.Close();
 
    43 
    46 }
 
    44 bool AfStorageProxyPrivate::addActivity(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
 
    47 
       
    48 bool AfStorageProxyPrivate::addActivity(int applicationId, const QString &activityId, const QString &customActivityName, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
 
    45 {    
    49 {    
    46     int screenshotHandle(-1);
 
    50     int screenshotHandle(-1);
 
    47     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
 
    51     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
 
    48     if (bitmap) {
 
    52     if (bitmap) {
 
    49         screenshotHandle = bitmap->Handle();
 
    53         screenshotHandle = bitmap->Handle();
 
    50     }
 
    54     }
 
    51     
    55     
    52     CAfEntry *entry = createSaveEntry(applicationId, activityId, activityData, metadata);
 
    56     CAfEntry *entry = createSaveEntry(applicationId, activityId, customActivityName, activityData, metadata);
 
    53     int result = mClient->addActivity(*entry, screenshotHandle);    
    57     int result = mClient->addActivity(*entry, screenshotHandle);    
    54     delete entry;
 
    58     delete entry;
 
    55     delete bitmap;
 
    59     delete bitmap;
 
    56     
    60     
    57     return KErrNone == result;
 
    61     return KErrNone == result;
 
    58 }
 
    62 }
 
    59 
    63 
    60 bool AfStorageProxyPrivate::updateActivity(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
 
    64 bool AfStorageProxyPrivate::updateActivity(int applicationId, const QString &activityId, const QString &customActivityName, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
 
    61 {
 
    65 {
 
    62     int screenshotHandle(-1);
 
    66     int screenshotHandle(-1);
 
    63     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
 
    67     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
 
    64     if (bitmap) {
 
    68     if (bitmap) {
 
    65         screenshotHandle = bitmap->Handle();
 
    69         screenshotHandle = bitmap->Handle();
 
    66     }
 
    70     }
 
    67     
    71     
    68     CAfEntry *entry = createSaveEntry(applicationId, activityId, activityData, metadata);
 
    72     CAfEntry *entry = createSaveEntry(applicationId, activityId, customActivityName, activityData, metadata);
 
    69     int result = mClient->updateActivity(*entry, screenshotHandle);    
    73     int result = mClient->updateActivity(*entry, screenshotHandle);    
    70     delete entry;
 
    74     delete entry;
 
    71     delete bitmap;
 
    75     delete bitmap;
 
    72     
    76     
    73     return KErrNone == result;
 
    77     return KErrNone == result;
 
    74 }
 
    78 }
 
    75 
    79 
    76 bool AfStorageProxyPrivate::saveActivity(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
 
    80 bool AfStorageProxyPrivate::saveActivity(int applicationId, const QString &activityId, const QString &customActivityName, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)
 
    77 {
 
    81 {
 
    78     int screenshotHandle(-1);
 
    82     int screenshotHandle(-1);
 
    79     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
 
    83     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());
 
    80     if (bitmap) {
 
    84     if (bitmap) {
 
    81         screenshotHandle = bitmap->Handle();
 
    85         screenshotHandle = bitmap->Handle();
 
    82     }
 
    86     }
 
    83     
    87     
    84     CAfEntry *entry = createSaveEntry(applicationId, activityId, activityData, metadata);
 
    88     CAfEntry *entry = createSaveEntry(applicationId, activityId, customActivityName, activityData, metadata);
 
    85     int result = mClient->saveActivity(*entry, screenshotHandle);    
    89     int result = mClient->saveActivity(*entry, screenshotHandle);    
    86     delete entry;
 
    90     delete entry;
 
    87     delete bitmap;
 
    91     delete bitmap;
 
    88     
    92     
    89     return KErrNone == result;
 
    93     return KErrNone == result;
 
   103     int result = mClient->removeApplicationActivities(*entry);
 
   107     int result = mClient->removeApplicationActivities(*entry);
 
   104     delete entry;
 
   108     delete entry;
 
   105     return KErrNone == result;
 
   109     return KErrNone == result;
 
   106 }
 
   110 }
 
   107 
   111 
   108 bool AfStorageProxyPrivate::activities(QList<QVariantHash> &list)
 
   112 bool AfStorageProxyPrivate::activities(QList<QVariantHash> &list, int limit)
 
   109 {
 
   113 {
 
   110     RPointerArray<CAfEntry> results;
 
   114     RPointerArray<CAfEntry> results;
 
   111     
   115     
   112     int result = mClient->activities(results);
 
   116     int result = mClient->activities(results, limit);
 
   113     list.clear();
 
   117     list.clear();
 
   114     for (int i=0; i < results.Count(); ++i) {
 
   118     for (int i=0; i < results.Count(); ++i) {
 
   115         list.append(extractMetadata(results[i]));
 
   119         list.append(extractMetadata(results[i], false));
 
   116     }
 
   120     }
 
   117    
   121    
   118     results.ResetAndDestroy();
 
   122     results.ResetAndDestroy();
 
   119     return KErrNone == result;
 
   123     return KErrNone == result;
 
   120 }
 
   124 }
 
   154 bool AfStorageProxyPrivate::activityMetaData(QVariantHash &metadata, int applicationId, const QString &activityId)
 
   158 bool AfStorageProxyPrivate::activityMetaData(QVariantHash &metadata, int applicationId, const QString &activityId)
 
   155 {
 
   159 {
 
   156     CAfEntry *entry = getEntry(applicationId, activityId);
 
   160     CAfEntry *entry = getEntry(applicationId, activityId);
 
   157     
   161     
   158     if (entry) {
 
   162     if (entry) {
 
   159         metadata = extractMetadata(entry);
 
   163         metadata = extractMetadata(entry, true);
 
   160         delete entry;
 
   164         delete entry;
 
   161         return true;
 
   165         return true;
 
   162     }    
   166     }    
   163     
   167     
   164     return false;
 
   168     return false;
 
   223 }
 
   227 }
 
   224  
   228  
   225 CAfEntry *AfStorageProxyPrivate::createFilterEntry(int applicationId, const QString &activityId)
 
   229 CAfEntry *AfStorageProxyPrivate::createFilterEntry(int applicationId, const QString &activityId)
 
   226 {   
   230 {   
   227     CAfEntry *entry(0); 
   231     CAfEntry *entry(0); 
   228     QT_TRAP_THROWING(entry = CAfEntry::NewL(0, applicationId, TPtrC(static_cast<const TUint16*>(activityId.utf16())), KNullDesC(), KNullDesC8(), KNullDesC8()));
 
   232     QT_TRAP_THROWING(entry = CAfEntry::NewL(0, applicationId, TPtrC(static_cast<const TUint16*>(activityId.utf16())), KNullDesC(), KNullDesC(), KNullDesC8(), KNullDesC8()));
 
   229     return entry;
 
   233     return entry;
 
   230 }
 
   234 }
 
   231 
   235 
   232 CAfEntry *AfStorageProxyPrivate::createSaveEntry(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata)
 
   236 CAfEntry *AfStorageProxyPrivate::createSaveEntry(int applicationId, const QString &activityId, const QString &customActivityName, const QVariant &activityData, const QVariantHash &metadata)
 
   233 {   
   237 {   
   234     CAfEntry *entry(0); 
   238     CAfEntry *entry(0); 
   235     
   239     
   236     QT_TRAP_THROWING(
 
   240     QT_TRAP_THROWING(
 
   237         int flags(0);
 
   241         int flags(0);
 
   252             flags |= CAfEntry::Invisible;
 
   256             flags |= CAfEntry::Invisible;
 
   253         }
 
   257         }
 
   254         
   258         
   255         HBufC *actBuff = XQConversions::qStringToS60Desc(activityId);
 
   259         HBufC *actBuff = XQConversions::qStringToS60Desc(activityId);
 
   256         CleanupStack::PushL(actBuff);
 
   260         CleanupStack::PushL(actBuff);
 
       
   261         
       
   262         HBufC *customNameBuff = XQConversions::qStringToS60Desc(customActivityName);
 
       
   263         CleanupStack::PushL(customNameBuff);
 
       
   264         
   257         entry = CAfEntry::NewL(flags, 
   265         entry = CAfEntry::NewL(flags, 
   258                                applicationId, 
   266                                applicationId, 
   259                                *actBuff, 
   267                                *actBuff, 
       
   268                                *customNameBuff,
 
   260                                KNullDesC, 
   269                                KNullDesC, 
   261                                privateBuff, 
   270                                privateBuff, 
   262                                publicBuff);
 
   271                                publicBuff);
 
       
   272         CleanupStack::PopAndDestroy(customNameBuff);
 
   263         CleanupStack::PopAndDestroy(actBuff);
 
   273         CleanupStack::PopAndDestroy(actBuff);
 
   264         CleanupStack::PopAndDestroy(&publicBuff);
 
   274         CleanupStack::PopAndDestroy(&publicBuff);
 
   265         CleanupStack::PopAndDestroy(&privateBuff);
 
   275         CleanupStack::PopAndDestroy(&privateBuff);
 
   266     );
 
   276     );
 
   267     return entry;
 
   277     return entry;
 
   280     }
 
   290     }
 
   281     
   291     
   282     return resultEntry;
 
   292     return resultEntry;
 
   283 }
 
   293 }
 
   284 
   294 
   285 QVariantHash AfStorageProxyPrivate::extractMetadata(CAfEntry *entry)
 
   295 QVariantHash AfStorageProxyPrivate::extractMetadata(CAfEntry *entry, bool includePublicData)
 
   286 {
 
   296 {
 
   287     QVariantHash metadata;
 
   297     QVariantHash metadata;
 
   288     metadata << entry->Data(CAfEntry::Public);
 
   298     if (includePublicData) {
 
       
   299         metadata << entry->Data(CAfEntry::Public);
 
       
   300     }
 
   289     metadata.insert(ActivityApplicationKeyword, entry->ApplicationId());
 
   301     metadata.insert(ActivityApplicationKeyword, entry->ApplicationId());
 
   290     metadata.insert(ActivityActivityKeyword, XQConversions::s60DescToQString(entry->ActivityId()));
 
   302     metadata.insert(ActivityActivityKeyword, XQConversions::s60DescToQString(entry->ActivityId()));
 
       
   303     metadata.insert(ActivityApplicationName, activityDisplayText(entry));
 
   291     metadata.insert(ActivityScreenshotKeyword, XQConversions::s60DescToQString(entry->ImageSrc()));
 
   304     metadata.insert(ActivityScreenshotKeyword, XQConversions::s60DescToQString(entry->ImageSrc()));
 
   292     metadata.insert(ActivityPersistence, (entry->Flags() & CAfEntry::Persistent) ? true : false);
 
   305     metadata.insert(ActivityPersistence, (entry->Flags() & CAfEntry::Persistent) ? true : false);
 
   293     metadata.insert(ActivityVisibility, (entry->Flags() & CAfEntry::Invisible) ? false : true); 
   306     metadata.insert(ActivityVisibility, (entry->Flags() & CAfEntry::Invisible) ? false : true); 
   294     return metadata;
 
   307     return metadata;
 
   295 }
 
   308 }
 
   296 
   309 
       
   310 QString AfStorageProxyPrivate::activityDisplayText(CAfEntry *entry)
 
       
   311 {
 
       
   312     if (entry->CustomActivityName().Compare(KNullDesC()) == 0) {
 
       
   313         TApaAppInfo info;
 
       
   314         mAppArcSession.GetAppInfo(info, TUid::Uid(entry->ApplicationId()));
 
       
   315         return QString::fromUtf16(info.iShortCaption.Ptr(), info.iShortCaption.Length());        
       
   316     } else {
 
       
   317         return XQConversions::s60DescToQString(entry->CustomActivityName());
 
       
   318     }
 
       
   319 }
FCL/sf/mw/homescreensrv