Mercurial Mercurial > oss > FCL > sf > mw > remoteconn / 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.
mtpfws/mtpfw/src/cmtpdatacodegenerator.cpp
changeset 47 63cf70d3ecd8
parent 0 d0791faffa3f
equal deleted inserted replaced
44:a5deb6b96675 47:63cf70d3ecd8 
    21 
    21 
    22 #include "mtpservicecommon.h"
 
    22 #include "mtpservicecommon.h"
 
    23 #include "rmtpframework.h"
 
    23 #include "rmtpframework.h"
 
    24 #include "cmtpdatacodegenerator.h"
 
    24 #include "cmtpdatacodegenerator.h"
 
    25 #include "cmtpservicemgr.h"
 
    25 #include "cmtpservicemgr.h"
 
    26 
    26 #include "OstTraceDefinitions.h"
 
    27 
    27 #ifdef OST_TRACE_COMPILER_IN_USE
 
    28 
    28 #include "cmtpdatacodegeneratorTraces.h"
 
    29 // Class constants.
 
    29 #endif
 
    30 __FLOG_STMT(_LIT8(KComponent,"DataCodeGenerator");)
 
    30 
       
    31 
       
    32 
    31 
    33 
    32 const TUint16 KUndenfinedStartCode = EMTPCodeUndefined1Start + 1;
 
    34 const TUint16 KUndenfinedStartCode = EMTPCodeUndefined1Start + 1;
 
    33 const TUint16 KUndenfinedEndCode = EMTPCodeUndefined1End;
 
    35 const TUint16 KUndenfinedEndCode = EMTPCodeUndefined1End;
 
    34 
    36 
    35 
    37 
    42     return self;
 
    44     return self;
 
    43     }
 
    45     }
 
    44 
    46 
    45 CMTPDataCodeGenerator::~CMTPDataCodeGenerator()
 
    47 CMTPDataCodeGenerator::~CMTPDataCodeGenerator()
 
    46     {
 
    48     {
 
    47     __FLOG(_L8("CMTPDataCodeGenerator::~CMTPDataCodeGenerator - Entry"));
 
    49     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_CMTPDATACODEGENERATOR_DES_ENTRY );
 
    48 
    50 
    49     iSingletons.Close();
 
    51     iSingletons.Close();
 
    50 
    52 
    51     __FLOG(_L8("CMTPDataCodeGenerator::~CMTPDataCodeGenerator - Exit"));
 
    53     OstTraceFunctionExit0( CMTPDATACODEGENERATOR_CMTPDATACODEGENERATOR_DES_EXIT );
 
    52     
       
    53     __FLOG_CLOSE;
 
       
    54     }
 
    54     }
 
    55 
    55 
    56 void CMTPDataCodeGenerator::ConstructL()
 
    56 void CMTPDataCodeGenerator::ConstructL()
 
    57     {
 
    57     {
 
    58     __FLOG_OPEN(KMTPSubsystem, KComponent);
 
    58     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_CONSTRUCTL_ENTRY );
 
    59     __FLOG(_L8("CMTPDataCodeGenerator::ConstructL - Entry"));
 
       
    60 
    59 
    61     iSingletons.OpenL ();
 
    60     iSingletons.OpenL ();
 
    62 
    61 
    63     __FLOG(_L8("CMTPDataCodeGenerator::ConstructL - Exit"));
 
    62     OstTraceFunctionExit0( CMTPDATACODEGENERATOR_CONSTRUCTL_EXIT );
 
    64     }
 
    63     }
 
    65 
    64 
    66 CMTPDataCodeGenerator::CMTPDataCodeGenerator() :
 
    65 CMTPDataCodeGenerator::CMTPDataCodeGenerator() :
 
    67     iUndefinedNextCode(KUndenfinedStartCode ),
 
    66     iUndefinedNextCode(KUndenfinedStartCode ),
 
    68     iVendorExtFormatCode(EMTPFormatCodeVendorExtDynamicStart)
 
    67     iVendorExtFormatCode(EMTPFormatCodeVendorExtDynamicStart)
 
    70 
    69 
    71     }
 
    70     }
 
    72 
    71 
    73 TInt CMTPDataCodeGenerator::IncServiceIDResource( const TUint aServiceType, TUint& aServiceID )
 
    72 TInt CMTPDataCodeGenerator::IncServiceIDResource( const TUint aServiceType, TUint& aServiceID )
 
    74     {
 
    73     {
 
    75     __FLOG(_L8("CMTPDataCodeGenerator::IncServiceIDResource - Entry"));
 
    74     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_INCSERVICEIDRESOURCE_ENTRY);
 
       
    75 
    76     if ( iUndefinedNextCode >= KUndenfinedEndCode )
 
    76     if ( iUndefinedNextCode >= KUndenfinedEndCode )
 
    77         return KErrOverflow;
 
    77         return KErrOverflow;
 
    78     
    78     
    79     switch ( aServiceType )
 
    79     switch ( aServiceType )
 
    80        {
 
    80        {
 
    89            aServiceID = ( (++iUndefinedNextCode) | KAbstrackServiceTypeMask );
 
    89            aServiceID = ( (++iUndefinedNextCode) | KAbstrackServiceTypeMask );
 
    90            }
 
    90            }
 
    91            break;
 
    91            break;
 
    92        default:
 
    92        default:
 
    93            {
 
    93            {
 
    94            __FLOG(_L8("CMTPDataCodeGenerator::IncServiceIDResource - Service Type not supported")); 
    94            OstTrace0( TRACE_NORMAL, CMTPDATACODEGENERATOR_INCSERVICEIDRESOURCE, "CMTPDataCodeGenerator::IncServiceIDResource - Service Type not supported" );          
    95            }
 
    95            }
 
    96        }
 
    96        }
 
    97     __FLOG(_L8("CMTPDataCodeGenerator::IncServiceIDResource - Exit"));
 
    97 
       
    98     OstTraceFunctionExit0( CMTPDATACODEGENERATOR_INCSERVICEIDRESOURCE_EXIT);
 
    98     return KErrNone;
 
    99     return KErrNone;
 
    99     }
 
   100     }
 
   100 
   101 
   101 void CMTPDataCodeGenerator::DecServiceIDResource()
 
   102 void CMTPDataCodeGenerator::DecServiceIDResource()
 
   102     {
 
   103     {
 
   103     __FLOG(_L8("CMTPDataCodeGenerator::DecServiceIDResource - Entry"));
 
   104     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_DECSERVICEIDRESOURCE_ENTRY );
 
   104     iUndefinedNextCode--;
 
   105     iUndefinedNextCode--;
 
   105     __FLOG(_L8("CMTPDataCodeGenerator::DecServiceIDResource - Exit"));
 
   106     OstTraceFunctionExit0( CMTPDATACODEGENERATOR_DECSERVICEIDRESOURCE_EXIT );
 
   106     }
 
   107     }
 
   107 
   108 
   108 TBool CMTPDataCodeGenerator::IsValidServiceType( const TUint aServiceType ) const
 
   109 TBool CMTPDataCodeGenerator::IsValidServiceType( const TUint aServiceType ) const
 
   109     {
 
   110     {
 
   110     return ( (EMTPServiceTypeNormal == aServiceType) || (EMTPServiceTypeAbstract == aServiceType) );
 
   111     return ( (EMTPServiceTypeNormal == aServiceType) || (EMTPServiceTypeAbstract == aServiceType) );
 
   111     }
 
   112     }
 
   112 
   113 
   113 TInt CMTPDataCodeGenerator::AllocateServiceID(const TMTPTypeGuid& aPGUID, const TUint aServiceType, TUint& aServiceID )
 
   114 TInt CMTPDataCodeGenerator::AllocateServiceID(const TMTPTypeGuid& aPGUID, const TUint aServiceType, TUint& aServiceID )
 
   114     {
 
   115     {
 
   115     __FLOG(_L8("CMTPDataCodeGenerator::AllocateServiceID - Entry"));
 
   116     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_ALLOCATESERVICEID_ENTRY );
 
   116     
   117     
   117     if( !IsValidServiceType(aServiceType) )
 
   118     if( !IsValidServiceType(aServiceType) )
 
       
   119         {
 
       
   120         OstTraceFunctionExit0( CMTPDATACODEGENERATOR_ALLOCATESERVICEID_EXIT );
 
   118         return KErrArgument;
 
   121         return KErrArgument;
 
   119         
   122         }
 
       
   123     
   120     TInt err(KErrNone);
 
   124     TInt err(KErrNone);
 
   121     TUint retID (KInvliadServiceID);
 
   125     TUint retID (KInvliadServiceID);
 
   122     if( iSingletons.ServiceMgr().IsSupportedService(aPGUID) )
 
   126     if( iSingletons.ServiceMgr().IsSupportedService(aPGUID) )
 
   123         {
 
   127         {
 
   124         if( iSingletons.ServiceMgr().ServiceTypeOfSupportedService(aPGUID) != aServiceType )
 
   128         if( iSingletons.ServiceMgr().ServiceTypeOfSupportedService(aPGUID) != aServiceType )
 
       
   129             {
 
       
   130             OstTraceFunctionExit0( DUP1_CMTPDATACODEGENERATOR_ALLOCATESERVICEID_EXIT );
 
   125             return KErrArgument;
 
   131             return KErrArgument;
 
   126             
   132             }
 
       
   133                        
   127         err = iSingletons.ServiceMgr().GetServiceId(aPGUID , retID);
 
   134         err = iSingletons.ServiceMgr().GetServiceId(aPGUID , retID);
 
   128         if( KErrNone != err )
 
   135         if( KErrNone != err )
 
   129             {
 
   136             {
 
   130             if((err = IncServiceIDResource( aServiceType, retID )) != KErrNone)
 
   137             if((err = IncServiceIDResource( aServiceType, retID )) != KErrNone)
 
       
   138                 {
 
       
   139                 OstTraceFunctionExit0( DUP2_CMTPDATACODEGENERATOR_ALLOCATESERVICEID_EXIT );
 
   131                 return err;
 
   140                 return err;
 
   132             
   141                 }
 
       
   142                             
   133             err = iSingletons.ServiceMgr().EnableService( aPGUID, retID );
 
   143             err = iSingletons.ServiceMgr().EnableService( aPGUID, retID );
 
   134             if( KErrNone != err )
 
   144             if( KErrNone != err )
 
   135                 {
 
   145                 {
 
   136                 DecServiceIDResource();
 
   146                 DecServiceIDResource();
 
       
   147                 OstTraceFunctionExit0( DUP3_CMTPDATACODEGENERATOR_ALLOCATESERVICEID_EXIT );
 
   137                 return err;
 
   148                 return err;
 
   138                 }
 
   149                 }
 
   139             }
 
   150             }
 
   140         
   151         
   141         }
 
   152         }
 
   142     else
 
   153     else
 
   143         {
 
   154         {
 
   144         if((err = IncServiceIDResource( aServiceType, retID )) != KErrNone)
 
   155         if((err = IncServiceIDResource( aServiceType, retID )) != KErrNone)
 
       
   156             {
 
       
   157             OstTraceFunctionExit0( DUP4_CMTPDATACODEGENERATOR_ALLOCATESERVICEID_EXIT );
 
   145             return err;
 
   158             return err;
 
       
   159             }
 
   146         }
 
   160         }
 
   147     
   161     
   148    aServiceID = retID;
 
   162    aServiceID = retID;
 
   149    iSingletons.ServiceMgr().InsertServiceId( retID );
 
   163    iSingletons.ServiceMgr().InsertServiceId( retID );
 
   150 
   164 
   151     __FLOG(_L8("CMTPDataCodeGenerator::AllocateServiceID - Exit"));
 
   165     OstTraceFunctionExit0( DUP5_CMTPDATACODEGENERATOR_ALLOCATESERVICEID_EXIT );
 
   152     return KErrNone;
 
   166     return KErrNone;
 
   153     }
 
   167     }
 
   154 
   168 
   155 TInt CMTPDataCodeGenerator::AllocateServicePropertyCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aPKNamespace, const TUint aPKID, TUint16& aServicePropertyCode )
 
   169 TInt CMTPDataCodeGenerator::AllocateServicePropertyCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aPKNamespace, const TUint aPKID, TUint16& aServicePropertyCode )
 
   156     {
 
   170     {
 
   157     __FLOG(_L8("CMTPDataCodeGenerator::AllocateServicePropertyCode - Entry"));
 
   171     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_ALLOCATESERVICEPROPERTYCODE_ENTRY );
 
   158 
   172 
   159     TUint retID = KInvliadU16DataCode;
 
   173     TUint retID = KInvliadU16DataCode;
 
   160     if( iSingletons.ServiceMgr().IsSupportedService(aServicePGUID) )
 
   174     if( iSingletons.ServiceMgr().IsSupportedService(aServicePGUID) )
 
   161         {
 
   175         {
 
   162         TInt err = iSingletons.ServiceMgr().GetServicePropertyCode( aServicePGUID, aPKNamespace, aPKID, retID );
 
   176         TInt err = iSingletons.ServiceMgr().GetServicePropertyCode( aServicePGUID, aPKNamespace, aPKID, retID );
 
   163         if( KErrNone != err )
 
   177         if( KErrNone != err )
 
       
   178             {
 
       
   179             OstTraceFunctionExit0( CMTPDATACODEGENERATOR_ALLOCATESERVICEPROPERTYCODE_EXIT );
 
   164             return err;
 
   180             return err;
 
   165 
   181             }
 
       
   182         
   166         if(retID == KInvliadU16DataCode)
 
   183         if(retID == KInvliadU16DataCode)
 
   167            {
 
   184            {
 
   168            if ( iUndefinedNextCode >= KUndenfinedEndCode )
 
   185            if ( iUndefinedNextCode >= KUndenfinedEndCode )
 
       
   186                {
 
       
   187                OstTraceFunctionExit0( DUP1_CMTPDATACODEGENERATOR_ALLOCATESERVICEPROPERTYCODE_EXIT );
 
   169                return KErrOverflow;
 
   188                return KErrOverflow;
 
       
   189                }
 
   170            
   190            
   171            retID = ++iUndefinedNextCode;
 
   191            retID = ++iUndefinedNextCode;
 
   172            iSingletons.ServiceMgr().SetServicePropertyCode( aServicePGUID, aPKNamespace, aPKID, retID);
 
   192            iSingletons.ServiceMgr().SetServicePropertyCode( aServicePGUID, aPKNamespace, aPKID, retID);
 
   173            }
 
   193            }
 
   174         }
 
   194         }
 
   175     else
 
   195     else
 
   176         {
 
   196         {
 
   177         if ( iUndefinedNextCode >= KUndenfinedEndCode )
 
   197         if ( iUndefinedNextCode >= KUndenfinedEndCode )
 
       
   198             {
 
       
   199             OstTraceFunctionExit0( DUP2_CMTPDATACODEGENERATOR_ALLOCATESERVICEPROPERTYCODE_EXIT );
 
   178             return KErrOverflow;
 
   200             return KErrOverflow;
 
       
   201             }
 
       
   202             
   179     
   203     
   180         retID = ++iUndefinedNextCode;
 
   204         retID = ++iUndefinedNextCode;
 
   181         }
 
   205         }
 
   182     
   206     
   183     aServicePropertyCode = retID;
 
   207     aServicePropertyCode = retID;
 
   184     
   208     
   185     __FLOG(_L8("CMTPDataCodeGenerator::AllocateServicePropertyCode - Exit"));
 
   209     OstTraceFunctionExit0( DUP3_CMTPDATACODEGENERATOR_ALLOCATESERVICEPROPERTYCODE_EXIT );
 
   186     return KErrNone;
 
   210     return KErrNone;
 
   187     }
 
   211     }
 
   188 
   212 
   189 TInt CMTPDataCodeGenerator::AllocateServiceFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint16& aServiceFormatCode )
 
   213 TInt CMTPDataCodeGenerator::AllocateServiceFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint16& aServiceFormatCode )
 
   190     {
 
   214     {
 
   191     __FLOG(_L8("CMTPServiceConfig::AllocateServiceFormatCode - Entry"));
 
   215     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_ALLOCATESERVICEFORMATCODE_ENTRY );
 
   192 
   216 
   193     TUint retID = KInvliadU16DataCode;
 
   217     TUint retID = KInvliadU16DataCode;
 
   194     if( iSingletons.ServiceMgr().IsSupportedService(aServicePGUID) )
 
   218     if( iSingletons.ServiceMgr().IsSupportedService(aServicePGUID) )
 
   195         {
 
   219         {
 
   196         TInt err = iSingletons.ServiceMgr().GetServiceFormatCode( aServicePGUID, aGUID, retID );
 
   220         TInt err = iSingletons.ServiceMgr().GetServiceFormatCode( aServicePGUID, aGUID, retID );
 
   197         if( KErrNone != err )
 
   221         if( KErrNone != err )
 
       
   222             {
 
       
   223             OstTraceFunctionExit0( CMTPDATACODEGENERATOR_ALLOCATESERVICEFORMATCODE_EXIT );
 
   198             return err;
 
   224             return err;
 
   199 
   225             }
 
       
   226         
   200         if(retID == KInvliadU16DataCode)
 
   227         if(retID == KInvliadU16DataCode)
 
   201            {
 
   228            {
 
   202            if ( iVendorExtFormatCode > EMTPFormatCodeVendorExtDynamicEnd )
 
   229            if ( iVendorExtFormatCode > EMTPFormatCodeVendorExtDynamicEnd )
 
       
   230                {
 
       
   231                OstTraceFunctionExit0( DUP1_CMTPDATACODEGENERATOR_ALLOCATESERVICEFORMATCODE_EXIT );
 
   203                return KErrOverflow;
 
   232                return KErrOverflow;
 
       
   233                }
 
   204            
   234            
   205            retID = ++iVendorExtFormatCode;
 
   235            retID = ++iVendorExtFormatCode;
 
   206            iSingletons.ServiceMgr().SetServiceFormatCode( aServicePGUID, aGUID, retID);
 
   236            iSingletons.ServiceMgr().SetServiceFormatCode( aServicePGUID, aGUID, retID);
 
   207            }
 
   237            }
 
   208         }
 
   238         }
 
   209     else
 
   239     else
 
   210         {
 
   240         {
 
   211         if ( iVendorExtFormatCode > EMTPFormatCodeVendorExtDynamicEnd )
 
   241         if ( iVendorExtFormatCode > EMTPFormatCodeVendorExtDynamicEnd )
 
       
   242             {
 
       
   243             OstTraceFunctionExit0( DUP2_CMTPDATACODEGENERATOR_ALLOCATESERVICEFORMATCODE_EXIT );
 
   212             return KErrOverflow;
 
   244             return KErrOverflow;
 
   213             
   245             }
 
       
   246         
   214         retID = ++iVendorExtFormatCode;
 
   247         retID = ++iVendorExtFormatCode;
 
   215         }
 
   248         }
 
   216     
   249     
   217     aServiceFormatCode = retID;
 
   250     aServiceFormatCode = retID;
 
   218     
   251     
   219     __FLOG(_L8("CMTPServiceConfig::AllocateServiceFormatCode - Exit"));
 
   252 
       
   253     OstTraceFunctionExit0( DUP3_CMTPDATACODEGENERATOR_ALLOCATESERVICEFORMATCODE_EXIT );
 
   220     return KErrNone;
 
   254     return KErrNone;
 
   221     }
 
   255     }
 
   222 
   256 
   223 TInt CMTPDataCodeGenerator::AllocateServiceMethodFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint16& aMethodFormatCode )
 
   257 TInt CMTPDataCodeGenerator::AllocateServiceMethodFormatCode( const TMTPTypeGuid& aServicePGUID, const TMTPTypeGuid& aGUID, TUint16& aMethodFormatCode )
 
   224     {
 
   258     {
 
   225     __FLOG(_L8("CMTPDataCodeGenerator::AllocateServiceMethodFormatCode - Entry"));
 
   259     OstTraceFunctionEntry0( CMTPDATACODEGENERATOR_ALLOCATESERVICEMETHODFORMATCODE_ENTRY );
 
   226     
   260     
   227     TUint retID = KInvliadU16DataCode;
 
   261     TUint retID = KInvliadU16DataCode;
 
   228     if( iSingletons.ServiceMgr().IsSupportedService(aServicePGUID) )
 
   262     if( iSingletons.ServiceMgr().IsSupportedService(aServicePGUID) )
 
   229         {
 
   263         {
 
   230         TInt err = iSingletons.ServiceMgr().GetServiceMethodCode( aServicePGUID, aGUID, retID );
 
   264         TInt err = iSingletons.ServiceMgr().GetServiceMethodCode( aServicePGUID, aGUID, retID );
 
   231         if( KErrNone != err )
 
   265         if( KErrNone != err )
 
       
   266             {
 
       
   267             OstTraceFunctionExit0( CMTPDATACODEGENERATOR_ALLOCATESERVICEMETHODFORMATCODE_EXIT );
 
   232             return err;
 
   268             return err;
 
   233     
   269             }
 
       
   270         
   234         if(retID == KInvliadU16DataCode)
 
   271         if(retID == KInvliadU16DataCode)
 
   235            {
 
   272            {
 
   236            if ( iUndefinedNextCode > KUndenfinedEndCode )
 
   273            if ( iUndefinedNextCode > KUndenfinedEndCode )
 
       
   274                {
 
       
   275                OstTraceFunctionExit0( DUP1_CMTPDATACODEGENERATOR_ALLOCATESERVICEMETHODFORMATCODE_EXIT );
 
   237                return KErrOverflow;
 
   276                return KErrOverflow;
 
       
   277                }
 
   238            
   278            
   239            retID = ++iUndefinedNextCode;
 
   279            retID = ++iUndefinedNextCode;
 
   240            iSingletons.ServiceMgr().SetServiceMethodCode( aServicePGUID, aGUID, retID);
 
   280            iSingletons.ServiceMgr().SetServiceMethodCode( aServicePGUID, aGUID, retID);
 
   241            }
 
   281            }
 
   242         }
 
   282         }
 
   243     else
 
   283     else
 
   244         {
 
   284         {
 
   245         if ( iUndefinedNextCode > KUndenfinedEndCode )
 
   285         if ( iUndefinedNextCode > KUndenfinedEndCode )
 
       
   286             {
 
       
   287             OstTraceFunctionExit0( DUP2_CMTPDATACODEGENERATOR_ALLOCATESERVICEMETHODFORMATCODE_EXIT );
 
   246             return KErrOverflow;
 
   288             return KErrOverflow;
 
   247             
   289             }
 
       
   290         
   248         retID = ++iUndefinedNextCode;
 
   291         retID = ++iUndefinedNextCode;
 
   249         }
 
   292         }
 
   250     
   293     
   251     aMethodFormatCode = retID;
 
   294     aMethodFormatCode = retID;
 
   252     
   295     
   253     __FLOG(_L8("CMTPDataCodeGenerator::AllocateServiceMethodFormatCode - Exit"));
 
   296     OstTraceFunctionExit0( DUP3_CMTPDATACODEGENERATOR_ALLOCATESERVICEMETHODFORMATCODE_EXIT );
 
   254     return KErrNone;
 
   297     return KErrNone;
 
   255     }
 
   298     }
 
   256 
   299 
   257 
   300 
   258 
   301
FCL/sf/mw/remoteconn