1 /*

     2  * Copyright (c) 2009 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: hsmenucontentpublish.cpp

    15  *

    16  */

    17 

    18 #include <QString>

    19 #include <QDebug>

    20 

    21 #include "hsapp_defs.h"

    22 #include "caquery.h"

    23 #include "caentry.h"

    24 #include "caicondescription.h"

    25 #include "caservice.h"

    26 

    27 #include "hsmenucontentpublish.h"

    28 #include "hsmenucontentpublish_p.h"

    29 

    30 HsMenuContentPublish::HsMenuContentPublish(QObject *parent)

    31     :QObject(parent), m_d(new HsMenuContentPublishPrivate(this))

    32 {

    33  

    34 }

    35 

    36 HsMenuContentPublish::~HsMenuContentPublish()

    37 {

    38     delete m_d;

    39 }

    40 

    41 bool HsMenuContentPublish::add(const QVariantMap &entryPreference)

    42 {    

    43     return m_d->add(entryPreference);

    44 }

    45 bool HsMenuContentPublish::remove(const QVariantMap &entry) const

    46 {

    47     return m_d->remove(entry);

    48 }

    49 

    50 QList<QVariantMap > HsMenuContentPublish::getList(const QVariantMap &queryPreference)

    51 {

    52     return m_d->getList(queryPreference);

    53 }

    54 

    55 /*!

    56  Constructor

    57  \param publishPublic pointer to public contentPublish

    58  */

    59 HsMenuContentPublishPrivate::HsMenuContentPublishPrivate(HsMenuContentPublish *publishPublic) :

    60     m_q(publishPublic)

    61 {

    62 

    63 }

    64 

    65 /*!

    66  destructor

    67  */

    68 HsMenuContentPublishPrivate::~HsMenuContentPublishPrivate()

    69 {

    70     

    71 }

    72 

    73 bool HsMenuContentPublishPrivate::add(const QVariantMap &entryPreference)

    74 {

    75     bool result = false;

    76     QMap<QString, QVariant> pref = entryPreference;

    77     

    78     CaIconDescription iconDesc;

    79     if(pref.contains(hsItemId))

    80         {

    81             CaEntry *update_entry = CaService::instance()->getEntry(pref.take(hsItemId).toInt());

    82             

    83             update_entry->setText(pref.take(hsItemName).toString());

    84             

    85             update_entry->setDescription(pref.take(hsItemDescription).toString());

    86             

    87             iconDesc.setFilename(pref.take(hsIconFileName).toString());

    88             iconDesc.setSkinId(pref.take(hsIconName).toString());

    89             iconDesc.setApplicationId(pref.take(hsIconApplicationId).toString());

    90             update_entry->setIconDescription(iconDesc);

    91             QMapIterator<QString, QVariant> k(pref);

    92             while (k.hasNext()) {

    93                 k.next();

    94                 update_entry->setAttribute(k.key(),k.value().toString());

    95             }

    96             

    97             result = CaService::instance()->updateEntry(*update_entry);

    98         }

    99     else if (pref.contains(hsItemName) && pref.contains(hsitemLaunchUri) && pref.contains(hsitemPublisherId))

   100         {

   101             CaEntry add_entry(ItemEntryRole);

   102             add_entry.setEntryTypeName(templatedApplicationTypeName());

   103             // mandatory values

   104             add_entry.setText(pref.take(hsItemName).toString());

   105             

   106             iconDesc.setFilename(pref.take(hsIconFileName).toString());

   107             iconDesc.setSkinId(pref.take(hsIconName).toString());

   108             iconDesc.setApplicationId(pref.take(hsIconApplicationId).toString());            

   109             add_entry.setIconDescription(iconDesc);  

   110             

   111             add_entry.setDescription(pref.take(hsItemDescription).toString());

   112             QMapIterator<QString, QVariant> k(pref);

   113             while (k.hasNext()) {

   114                 k.next();

   115                 add_entry.setAttribute(k.key(),k.value().toString());

   116             }

   117 

   118             add_entry.setFlags(add_entry.flags() & ~RemovableEntryFlag);

   119             

   120             CaEntry *entry = CaService::instance()->createEntry(add_entry);

   121             if (entry) {

   122                 result = true;

   123                 delete entry;

   124             }      

   125         }

   126     else

   127         {

   128             return false;

   129         }

   130     return result;

   131     

   132   

   133 }

   134 bool HsMenuContentPublishPrivate::remove(const QVariantMap &entry) const

   135 {

   136     bool result = false;

   137     if (entry.contains(hsItemId))

   138         {    

   139             result = CaService::instance()->removeEntry(entry.value(hsItemId).toInt());

   140         }

   141     return result;

   142 }

   143 

   144 QList<QVariantMap > HsMenuContentPublishPrivate::getList(const QVariantMap &queryPreference)

   145 {

   146     QList<QVariantMap> list;

   147     QMap<QString, QVariant> map = queryPreference;

   148     

   149     map.remove(hsItemName);

   150     map.remove(hsItemDescription);

   151     

   152     CaQuery query;

   153     // define query

   154     query.setFlagsOn(VisibleEntryFlag);

   155     query.setEntryRoles(ItemEntryRole);

   156     query.setEntryTypeNames(QStringList(templatedApplicationTypeName()));

   157     

   158     

   159     // add atributes to caquery

   160     QMapIterator<QString, QVariant> k(map);

   161     while (k.hasNext()) {

   162         k.next();

   163         query.setAttribute(k.key(),k.value().toString());

   164     }  

   165     QList<CaEntry *> entries = CaService::instance()->getEntries(query);

   166     map.clear();

   167     if (entries.count()) {

   168         QMap<QString, QString> attrMap;

   169         QMapIterator<QString, QString> k(attrMap);

   170         //walk trought entrys and extract keys into map

   171         for (int i = 0; i < entries.count(); ++i) {

   172             map[hsItemId] = entries.at(i)->id();

   173             map[hsItemName] = entries.at(i)->text();

   174             map[hsItemDescription] = entries.at(i)->description();

   175             CaIconDescription iconDesc = entries.at(i)->iconDescription();

   176             map[hsIconFileName] = iconDesc.filename();

   177             map[hsIconName] = iconDesc.skinId();

   178             map[hsIconApplicationId] = iconDesc.applicationId();

   179             

   180             // extract entry atributes

   181             attrMap = entries.at(i)->attributes();

   182             QMapIterator<QString, QString> k(attrMap);

   183             // insert entrys attr into map

   184             while (k.hasNext()) {

   185                 k.next();

   186                 map.insert(k.key(),k.value());

   187             }

   188             list.append(map); //append entry map to list

   189             // clean used maps

   190             map.clear();

   191             attrMap.clear();

   192         }

   193     }

   194     qDeleteAll(entries);

   195     return list;

   196 }