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:  HsRuntime factory.

    15 *

    16 */

    17 

    18 

    19 #include "hsruntimefactory.h"

    20 #include "hsruntimefactory_p.h"

    21 #include "hsruntimeprovidermanifest.h"

    22 #include "hstest_global.h"

    23 

    24 #include <QStringList>

    25 #include <QDir>

    26 #include <QPluginLoader>

    27 

    28 

    29 HsRuntimeFactoryPrivate::HsRuntimeFactoryPrivate(HsRuntimeFactory* aPublic)

    30     : QObject(aPublic),

    31       mQ(aPublic)

    32 {

    33 

    34 }

    35 

    36 

    37 HsRuntimeFactoryPrivate::~HsRuntimeFactoryPrivate()

    38 {

    39 

    40 }

    41 

    42 QList<HsRuntimeToken> HsRuntimeFactoryPrivate::runtimes()

    43 {

    44     QStringList pluginPaths;

    45 

    46     //Check plugin dirs from root of different drives

    47     QFileInfoList drives = QDir::drives();

    48     for(int i=0; i < drives.count(); i++)

    49     {

    50         QFileInfo drive = drives.at(i);

    51         QString driveLetter = drive.absolutePath();

    52         QString path = driveLetter + mPluginManifestDirectory;

    53         if(QDir(path).exists())

    54         {

    55             pluginPaths << path;

    56         }

    57     }

    58 

    59     //Check plugin dir relative to current dir

    60     if(QDir(mPluginManifestDirectory).exists() && !pluginPaths.contains(QDir(mPluginManifestDirectory).absolutePath()))

    61     {

    62         pluginPaths << mPluginManifestDirectory;

    63     }

    64 

    65     QList<HsRuntimeToken> runtimes;

    66 

    67     for(int h=0; h < pluginPaths.count(); h++)

    68     {

    69         QString path = pluginPaths.at(h);

    70         QDir dir(path);

    71         QStringList filters("*.manifest");

    72 

    73         for(int i=0; i < dir.entryList(filters, QDir::Files).count(); ++i)

    74         {

    75             QString fileName = dir.entryList(filters, QDir::Files).at(i);

    76 

    77             HsRuntimeProviderManifest manifest;

    78             manifest.loadFromXml(dir.absoluteFilePath(fileName));

    79 

    80             if(manifest.loadOnQuery())

    81             {

    82                 QList<HsRuntimeToken> tokens = manifest.runtimes();

    83                 for(int j=0; j < tokens.count(); ++j)

    84                 {

    85                     HsRuntimeToken token = tokens.at(j);

    86                     IHsRuntimeProvider* provider = loadProviderFromPlugin(token.mLibrary);

    87                     if(provider)

    88                     {

    89                         runtimes << provider->runtimes();

    90                         delete provider;

    91                     }

    92                 }

    93             }

    94             else

    95             {

    96                 runtimes << manifest.runtimes();

    97             }

    98         }

    99     }

   100     return runtimes;

   101 }

   102 

   103 HsRuntime* HsRuntimeFactoryPrivate::createRuntime(const HsRuntimeToken& aToken)

   104 {

   105     IHsRuntimeProvider* provider = loadProviderFromPlugin(aToken.mLibrary);

   106     if(!provider)

   107     {

   108         HSDEBUG("Runtime creation failed - No provider.")

   109         return 0;

   110     }

   111 

   112     HsRuntime* runtime = provider->createRuntime(aToken);

   113     delete provider;

   114     if(!runtime)

   115     {

   116         HSDEBUG("Runtime creation failed.")

   117     }

   118     return runtime;

   119 }

   120 

   121 IHsRuntimeProvider* HsRuntimeFactoryPrivate::loadProviderFromPlugin(const QString& aPluginName)

   122 {

   123     QStringList pluginPaths;

   124 

   125     //Check plugin dirs from root of different drives

   126     QFileInfoList drives = QDir::drives();

   127     for(int i=0; i < drives.count(); i++)

   128     {

   129         QFileInfo drive = drives.at(i);

   130         QString driveLetter = drive.absolutePath();

   131         QString path = driveLetter + mPluginDirectory;

   132         if(QDir(path).exists())

   133         {

   134             pluginPaths << path;

   135         }

   136     }

   137 

   138 

   139     //Check plugin dir relative to current dir

   140     if(QDir(mPluginManifestDirectory).exists() && !pluginPaths.contains(QDir(mPluginDirectory).absolutePath()))

   141     {

   142         pluginPaths << mPluginDirectory;

   143     }

   144 

   145     IHsRuntimeProvider* provider = 0;

   146     QPluginLoader loader;

   147     QObject* plugin = 0;

   148 

   149     for(int i=0; i < pluginPaths.count(); i++)

   150     {

   151         QString path = pluginPaths.at(i);

   152         QString fileName = QDir(path).absoluteFilePath(aPluginName);

   153 

   154         loader.setFileName(fileName);

   155         plugin = loader.instance();

   156         provider = qobject_cast<IHsRuntimeProvider*>(plugin);

   157         if(provider)

   158         {

   159             return provider;

   160         }

   161 

   162         //Don't leak memory if provider not IHsRuntimeProvider

   163         if(plugin)

   164         {

   165             HSDEBUG("Runtime provider load - !provider, deleting plugin.")

   166             delete plugin;

   167         }

   168     }

   169 

   170     HSDEBUG("Runtime provider load failed - Not found.")

   171     return 0;

   172 }

   173 

   174 /*!

   175     \class HsRuntimeFactory

   176     \ingroup group_hsruntimemodel

   177     \brief Finds and creates home screen runtimes.

   178 

   179     HsRuntime factory finds home screen runtimes from HsRuntime provider 

   180     plugins. The search is done based on given plugin manifest

   181     and plugin binary directories. Found runtimes are returned as

   182     a list of HsRuntime tokens. HsRuntime factory creates an instance of

   183     a HsRuntime base on a HsRuntime token that is given to it.

   184 */

   185 

   186 /*!

   187     Constructor.

   188     

   189     \a aPluginManifestDirectory Directory that contains plugin manifests.

   190     \a aPluginDirectory Directory that contains plugin binaries.

   191     \a aParent Parent object.

   192 */

   193 HsRuntimeFactory::HsRuntimeFactory(const QString& aPluginManifestDirectory,

   194                                const QString& aPluginDirectory,

   195                                QObject* aParent)

   196     : QObject(aParent)

   197 {

   198     mD = new HsRuntimeFactoryPrivate(this);

   199     mD->mPluginManifestDirectory = aPluginManifestDirectory;

   200     mD->mPluginDirectory = aPluginDirectory;

   201 }

   202 

   203 /*!

   204     Destructor.    

   205 */

   206 HsRuntimeFactory::~HsRuntimeFactory()

   207 {

   208 

   209 }

   210 

   211 /*!

   212     Returns found runtimes as a list of HsRuntime tokens.    

   213 */

   214 QList<HsRuntimeToken> HsRuntimeFactory::runtimes()

   215 {

   216     return mD->runtimes();

   217 }

   218 

   219 /*!

   220     Creates and returns a HsRuntime based on the given token.    

   221     \a aToken Identifies the HsRuntime to be created.

   222 

   223     Return The created HsRuntime.

   224 */

   225 HsRuntime* HsRuntimeFactory::createRuntime(const HsRuntimeToken& aToken)

   226 {

   227     return mD->createRuntime(aToken);

   228 }