idlefw/plugins/shortcutplugin/src/aidefaultshortcut.cpp
branchRCL_3
changeset 8 d0529222e3f0
parent 4 1a2a00e78665
child 11 bd874ee5e5e2
equal deleted inserted replaced
4:1a2a00e78665 8:d0529222e3f0
     1 /*
       
     2 * Copyright (c) 2005-2006 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:  Platform default shortcuts.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include "aidefaultshortcut.h"
       
    20 #include "taiscutparser.h"
       
    21 #include <centralrepository.h>
       
    22 #include <activeidle2domaincrkeys.h>
       
    23 #include <e32base.h>
       
    24 #include <libc/stddef.h>  // For wchar_t
       
    25 
       
    26 namespace {
       
    27 
       
    28        struct TDefaultShortcut
       
    29            {
       
    30            /**
       
    31             * Identifier
       
    32             */
       
    33            TInt id;
       
    34 
       
    35            /**
       
    36             * Key to identify this shortcut
       
    37             */
       
    38            TInt key;
       
    39 
       
    40            /**
       
    41             * Definition for this shortcut
       
    42             */
       
    43            const wchar_t* definition;
       
    44            };
       
    45        
       
    46        enum TDefaultShortcutCenrepId
       
    47            {
       
    48            EDefaultShortcutFirst = 0,
       
    49            EDefaultShortcutSecond,
       
    50            EDefaultShortcutThird,
       
    51            EDefaultShortcutFourth,
       
    52            EDefaultShortcutFifth,
       
    53            EDefaultShortcutSixth,
       
    54            EDefaultShortcutSeventh,
       
    55            EDefaultShortcutEighth,
       
    56            EDefaultShortcutNaviLeft,
       
    57            EDefaultShortcutNaviRight,
       
    58            EDefaultShortcutNaviUp,
       
    59            EDefaultShortcutNaviDown,
       
    60            EDefaultShortcutNaviKey,
       
    61            EDefaultShortcutLSK,
       
    62            EDefaultShortcutRSK
       
    63            };
       
    64        
       
    65  // Platform default shortcuts.
       
    66        const TDefaultShortcut KDefaultShortcuts[] =
       
    67        {
       
    68        { EDefaultShortcutFirst,     0x00000001, L"localapp:0x101F4CCE" },               // Phonebook,
       
    69        { EDefaultShortcutSecond,    0x00000002, L"localapp:0x100058C5" },               // Messaging,
       
    70        { EDefaultShortcutThird,     0x00000003, L"localapp:0x10008D39" },               // Browser,
       
    71        { EDefaultShortcutFourth,    0x00000004, L"localapp:0x200009EE" },               // Photos,
       
    72        { EDefaultShortcutFifth,     0x00000005, L"localapp:0x10005901" },               // Calendar,
       
    73        { EDefaultShortcutSixth,     0x00000006, L"localapp:msg?new=msg" },              // New message,
       
    74        { EDefaultShortcutSeventh,   0x00000007, L"localapp:0x102072C3" },               // Music Player,
       
    75        { EDefaultShortcutEighth,    0x00000008, L"localapp:0x10207A89" },               // Radio,
       
    76        { EDefaultShortcutNaviLeft,  0x01000000, L"localapp:0x100058C5?new=msg" },       // New message,
       
    77        { EDefaultShortcutNaviRight, 0x01000001, L"localapp:0x10005901" },                // Calendar,
       
    78        { EDefaultShortcutNaviUp,    0x01000002, L"localapp:0x101F4CCE" },               // Contacts,
       
    79        { EDefaultShortcutNaviDown,  0x01000003, L"localapp:0x101F4CCE" },                // Contacts,
       
    80        { EDefaultShortcutNaviKey,   0x01000004, L"localapp:0x100058C5" },               // Messagind,
       
    81        { EDefaultShortcutLSK,       0x01000100, L"localapp:0x101F4CD2" },                // Menu,
       
    82        { EDefaultShortcutRSK,       0x01000101, L"localapp:0x101F4CCE" }                // Contacts,
       
    83        };
       
    84        
       
    85        const TInt KDefaultShortcutCount = (sizeof(KDefaultShortcuts)/sizeof(KDefaultShortcuts[0])); 
       
    86 }
       
    87 
       
    88 inline TPtrC16 DefaultDefinition( const TDefaultShortcut& aShortcut )
       
    89     {
       
    90     return TPtrC16( (const TText16*) aShortcut.definition );
       
    91     }
       
    92 // ---------------------------------------------------------------------------
       
    93 //
       
    94 // ---------------------------------------------------------------------------
       
    95 //
       
    96 void GetPlatformDefaultShortcut(TInt aIndex, TUid& aUid, TDes& aDefinition)
       
    97     {
       
    98     TInt err = KErrNone;
       
    99     TAiScutParser parser;
       
   100     if (aIndex < 0)
       
   101         {
       
   102         aIndex = 0;
       
   103         }
       
   104 
       
   105     aIndex = aIndex % ::KDefaultShortcutCount;
       
   106     aDefinition.Copy( ::DefaultDefinition(::KDefaultShortcuts[aIndex]) );
       
   107 
       
   108     err = parser.Parse( aDefinition );
       
   109     if ( err == KErrNone )
       
   110         {
       
   111         aUid = TAiScutParser::ParseUid( parser.Get( EScutDefTarget) );
       
   112         }
       
   113     }
       
   114 
       
   115 // ---------------------------------------------------------------------------
       
   116 //
       
   117 // ---------------------------------------------------------------------------
       
   118 //
       
   119 TInt ResolveCenrepIdFromKey( TInt aKey, TInt &aCenrepId )
       
   120     {
       
   121     TInt ret = KErrNotFound;
       
   122     for ( TInt i = 0; i < KDefaultShortcutCount; ++i )
       
   123         {
       
   124         if ( KDefaultShortcuts[i].key == aKey )
       
   125             {            
       
   126             aCenrepId = KDefaultShortcuts[i].id;
       
   127             ret = KErrNone;
       
   128             break;
       
   129             }
       
   130         }
       
   131     return ret;
       
   132     }
       
   133 
       
   134 // ---------------------------------------------------------------------------
       
   135 //
       
   136 // ---------------------------------------------------------------------------
       
   137 //
       
   138 void TAiDefaultShortcut::GetDefaultShortcut(TInt aKey, TUid& aUid, TDes& aDefinition)
       
   139 {
       
   140     CRepository *cr = NULL;
       
   141     TInt err = KErrNone;
       
   142     TInt index = KErrNotFound;
       
   143     err = ::ResolveCenrepIdFromKey( aKey, index );
       
   144     TInt32 crIndex = KAIBackupShortcutDefinitionStart;
       
   145     if ( err == KErrNone )
       
   146         {
       
   147         TRAP( err, cr = CRepository::NewL( TUid::Uid( KCRUidActiveIdleLV ) ) );
       
   148 
       
   149         aUid.iUid = KErrNotFound;
       
   150         if ( err == KErrNone )
       
   151             {
       
   152             crIndex += index;
       
   153             err = cr->Get( crIndex, aDefinition );
       
   154             // In case of a null definition use the platform default
       
   155             if ( aDefinition.Length() <= 0 )
       
   156                 {
       
   157                 err = KErrNotFound;
       
   158                 }            
       
   159             else if ( err == KErrNone )
       
   160                 {
       
   161                 TAiScutParser parser;
       
   162                 err = parser.Parse( aDefinition );
       
   163                 if ( err == KErrNone )
       
   164                     {
       
   165                     aUid = TAiScutParser::ParseUid( parser.Get( EScutDefTarget) );
       
   166                     }
       
   167                 }               
       
   168             }           
       
   169         }
       
   170         
       
   171     // Ensure that some definition is returned
       
   172     // in case of any error occurrs
       
   173     if ( err != KErrNone )
       
   174         {
       
   175         ::GetPlatformDefaultShortcut( index, aUid, aDefinition );
       
   176         }    
       
   177     delete cr;
       
   178 }
       
   179 
       
   180 // End of File.