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:

    15 *

    16 */

    17 

    18 #include "afcommandlineparser.h"

    19 

    20 #include <QUrl>

    21 

    22 // Startup arguments for services

    23 static const char * StartupArgEmbedded = "embedded=yes";

    24 static const char * StartupArgService = "service=yes";

    25 static const char * StartupArgInterfaceId = "intf=";

    26 static const char * StartupArgOperationId = "oper=";

    27 static const char * StartupArgEmbeddedName = "embedded";

    28 static const char * StartupArgInterfaceName = "intf";

    29 static const char * StartupArgOperationName = "oper";

    30 

    31 // for activities

    32 const char KCmdLineMarker[] = "-activity";

    33 

    34 void AfCommandLineParser::parseCommandLine(const QStringList &commandLineParams,

    35             Af::ActivationReason &reason,

    36             QString &name,

    37             QVariantHash &parameters)

    38 {

    39     if (AfCommandLineParser::isServiceCommand(commandLineParams)) {

    40         parseServiceParameters(commandLineParams,

    41                 reason,

    42                 name,

    43                 parameters);

    44     }

    45     else if (AfCommandLineParser::isActivityCommand(commandLineParams)) {

    46         parseActivityParameters(commandLineParams,

    47                 reason,

    48                 name,

    49                 parameters);

    50     }  

    51 }

    52 

    53 bool AfCommandLineParser::isServiceCommand(const QStringList &commandLineParams)

    54 {

    55     return commandLineParams.contains(StartupArgService);

    56 }

    57 

    58 bool AfCommandLineParser::isActivityCommand(const QStringList &commandLineParams)

    59 {

    60     return commandLineParams.contains(KCmdLineMarker);

    61 }

    62 

    63 void AfCommandLineParser::parseServiceParameters(const QStringList &commandLineParams,

    64         Af::ActivationReason &reason,

    65         QString &name,

    66         QVariantHash &parameters)

    67 {

    68     reason = Af::ActivationReasonService;

    69     parameters = QVariantHash();

    70     int num = commandLineParams.count();

    71     for ( int i = 0; i < num; i++ ) {

    72         QString s = commandLineParams[i] ;

    73         if (s.startsWith(StartupArgInterfaceId)) {

    74             name = s.remove(StartupArgInterfaceId);

    75             parameters.insert(StartupArgInterfaceName,name);

    76         } 

    77         else if (s.startsWith(StartupArgOperationId)) {

    78             parameters.insert(StartupArgOperationName,s.remove(StartupArgOperationId));

    79         }

    80         else if (s.startsWith(StartupArgEmbedded)) {

    81             parameters.insert(StartupArgEmbeddedName,true);

    82         }

    83     }  

    84 }

    85 

    86 void AfCommandLineParser::parseActivityParameters(const QStringList &commandLineParams,

    87         Af::ActivationReason &reason,

    88         QString &name,

    89         QVariantHash &parameters)

    90 {

    91     QVariantHash startupActivity = AfCommandLineParser::getActivityParameters(commandLineParams);

    92     if (!startupActivity.isEmpty() && 

    93             !startupActivity.value(Af::KActivityUriNameKey).toString().isEmpty()) {

    94         reason = Af::ActivationReasonActivity;

    95         parameters = startupActivity;

    96         name = startupActivity.value(Af::KActivityUriNameKey).toString();

    97     }

    98 }

    99 

   100 QVariantHash AfCommandLineParser::getActivityParameters(const QStringList &commandLineParams)

   101 {

   102     QVariantHash activityParams;

   103     int activityMarkerIndex = commandLineParams.indexOf(KCmdLineMarker);

   104     if (activityMarkerIndex != -1 && commandLineParams.count() - 1 > activityMarkerIndex) {

   105         QUrl activityUri = QUrl::fromEncoded(commandLineParams.at(activityMarkerIndex+1).toAscii());

   106         if (activityUri.scheme() == Af::KActivityScheme) {

   107             QList<QPair<QString, QString> > parameters = activityUri.queryItems();

   108             for (QList<QPair<QString, QString> >::const_iterator i = parameters.constBegin(); i != parameters.constEnd(); ++i) {

   109                 activityParams.insert(i->first, i->second);

   110             }

   111 

   112             if (activityParams.contains(Af::KActivityUriNameKey) && !activityParams.value(Af::KActivityUriNameKey).toString().isEmpty()) {

   113                 return activityParams;

   114             }

   115         }

   116     }

   117     return QVariantHash();

   118 }