/**

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: CUpnpTmServerImpl class implementation.

*

*/

// Includes

#include "upnptmserverimpl.h"

#include "upnpiconfileservetransaction.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "upnptmserverimplTraces.h"

#endif

//Literals

_LIT8(KAppListStart,             "<appList>");

_LIT8(KAppListEnd,               "</appList>");

_LIT8(KAppIdStart,               "<appID>");

_LIT8(KAppIdEnd,                 "</appID>");

_LIT8(KNameStart,                "<name>");

_LIT8(KNameEnd,                  "</name>");

_LIT8(KIconStart,                "<icon>");

_LIT8(KIconEnd,                  "</icon>");

_LIT8(KMimeTypeStart,            "<mimetype>");

_LIT8(KMimeTypeEnd,              "</mimetype>");

_LIT8(KWidthStart,               "<width>");

_LIT8(KWidthEnd,                 "</width>");

_LIT8(KHeightStart,              "<height>");

_LIT8(KHeightEnd,                "</height>");

_LIT8(KDepthStart,               "<depth>");

_LIT8(KDepthEnd,                 "</depth>");

_LIT8(KUrlStart,                 "<url>");

_LIT8(KUrlEnd,                   "</url>");

_LIT8(KAllowedProfileIdsStart,   "<allowedProfileIDs>");

_LIT8(KAllowedProfileIdsEnd,     "</allowedProfileIDs>");

_LIT8(KResourceStatusStart,      "<resourceStatus>");

_LIT8(KResourceStatusEnd,        "</resourceStatus>");

_LIT8(KAppStatusListStart,       "<appStatusList>");

_LIT8(KAppStatusListEnd,         "</appStatusList>");

_LIT8(KAppStatusStart,           "<appStatus>");

_LIT8(KAppStatusEnd,             "</appStatus>");

_LIT8(KStatusStart,              "<status>");

_LIT8(KStatusEnd,                "</status>");

_LIT8(KProfileIdStart,           "<profileID>");

_LIT8(KProfileIdEnd,             "</profileID>");

_LIT8(KStatusTypeStart,          "<statusType>");

_LIT8(KStatusTypeEnd,            "</statusType>");

_LIT8(KStartTagOpenBracket,      "<");

_LIT8(KEndTagOpenBracket,        "</");

_LIT8(KCloseBracket,             ">");

// ================= MEMBER FUNCTIONS ==============================================

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::NewL

// Two-phased constructor.

// ---------------------------------------------------------------------------------

//

CUpnpTmServerImpl* CUpnpTmServerImpl::NewL( CUpnpTmServerDeviceInfo& aDeviceInfo,

                                           MUpnpTmServerObserver& aTmServerObserver)

    {

    CUpnpTmServerImpl* self = new (ELeave) CUpnpTmServerImpl( aTmServerObserver );   

    CleanupStack::PushL(self);

    self->ConstructL( aDeviceInfo );

    CleanupStack::Pop(self);

    return self;    

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::CUpnpTmServerImpl

// C++ default constructor can NOT contain any code, that

// might leave.

// ---------------------------------------------------------------------------------

//

CUpnpTmServerImpl::CUpnpTmServerImpl( MUpnpTmServerObserver& aTmServerObserver )

      :iTmServerObserver(aTmServerObserver)

     {

     }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::ConstructL

// Symbian 2nd phase constructor can leave.

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::ConstructL( CUpnpTmServerDeviceInfo& aDeviceInfo )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_CONSTRUCTL_ENTRY );

    iIapSetting = CUpnpSettings::NewL( KCRUidUPnPStack );

    /**

     *  Retrieve the IAP ID which has been set by DLNA and store it so that 

     *  it can be reverted back to the same when Automotive Server has stopped 

     *  making use of TM Service.

     */

    iIapId = CUpnpSettings::GetIapL(); 

    //Fetch the IAP ID set by the Automotive Server

    TInt iapId = aDeviceInfo.IapId();

    OstTrace1( TRACE_NORMAL, CUPNPTMSERVERIMPL_CONSTRUCTL, "CUpnpTmServerImpl::ConstructL;iapId=%d", iapId );

    // writes the iap id to the cenrep

    User::LeaveIfError( iIapSetting->Set( CUpnpSettings::KUPnPStackIapId, iapId ) ); 

    iTmServerDevice = CUpnpTmServerDevice::NewL( aDeviceInfo, *this );

    iAppStore = CUpnpRemotableAppStore::NewL();

    iIconMapping = CUpnpTmIconMapping::NewL();

    User::LeaveIfError( iIconFileSession.Connect() );

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_CONSTRUCTL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::~CUpnpTmServerImpl

// Destructor

// ---------------------------------------------------------------------------------

//

CUpnpTmServerImpl::~CUpnpTmServerImpl()

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_CUPNPTMSERVERIMPL_ENTRY );

    //Restore the IAP ID for DLNA use

    RestoreIap();

    delete iIapSetting;

    delete iFilteredAppList;

    iIconFileSession.Close();

    delete iAppStore;

    delete iIconMapping;

    iXmSignature.Close();

    iResponseBuf.Close();

    delete iTmServerDevice;

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_CUPNPTMSERVERIMPL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::RestoreIap

// Method is used to restore IAP ID which has been previously retreived so that

// DLNA continues to make use of it.

// This method is mainly provided to avoid codescanner tool error.

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::RestoreIap()

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_RESTOREIAP_ENTRY );

    OstTrace1( TRACE_NORMAL, CUPNPTMSERVERIMPL_RESTOREIAP, "CUpnpTmServerImpl::RestoreIap;iIapId=%d", iIapId );

    iIapSetting->Set( CUpnpSettings::KUPnPStackIapId, iIapId );    

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_RESTOREIAP_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::GetApplicationListL

// Method to create soap repsonse for GetApplicationList action.

// It generates a list of applications, which can be launched and terminated remotely.

// @param aAppListFilter Application Listing Filter. This is an optional parameter 

//                     used by the UPnP Control Point to limit the AppListing value to 

//                               those applications which meet the filter parameters.

// @param aProfileId  ProfileID of client profile whose parameter settings will be 

//                    applied for generating the application list

// @param aErr[out]   TerminalMode error code

// @return Returns soap response buffer 

// ---------------------------------------------------------------------------------

//

const TDesC8& CUpnpTmServerImpl::GetApplicationListL( const TDesC8& aAppListFilter,

                                     TUint aProfileId, TTerminalModeErrorCode& aErr )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_GETAPPLICATIONLISTL_ENTRY );

    iResponseBuf.Close();

    iResponseBuf.CreateL(KActionBufferLength);

    aErr = iTmServerObserver.OnGetApplicationList( aProfileId );  

    if ( aErr == ETerminalModeSuccess )

        {

        // Check for availability of AppListingFilter input argument in the soap action

        TInt filterStringFound = aAppListFilter.Find(Keq);

        if ( filterStringFound != KErrNotFound )

            {

            delete iFilteredAppList;

            iFilteredAppList = NULL;

            // Constructs a filter object and parses the input filter string

            iFilteredAppList = CUpnpTmFilteredAppList::NewL(*this);

            iFilteredAppList->ParseAppFilterStringL( aAppListFilter, aErr );

            }

        if ( aErr == ETerminalModeSuccess )

            {

            iProfileId = aProfileId; // Stored for generating app icon path in the soap response

            AppendDataL(KAppListStart);

            for ( TInt i(0) ; i < iAppStore->AppIdArray().Count(); i++)

                 {

                 // There can be 2 conditions assoicated with this

                 // 1.  AppListingFilter is "*"

                 // 2.  AppListingFilter has some filter string set

                 const RArray<TUint>& profileIdList = iAppStore->FetchRemotableApp(i).AllowedProfileIdList();

                 if ( ( profileIdList.Find(aProfileId) != KErrNotFound ) ||

                                                    ( profileIdList.Count() == KErrNone ))

                     {

                     // If the provided profileID is allowed profileID for the app

                     if (  filterStringFound == KErrNotFound )                 

                         {

                         // Constructs a non-filtered soap response

                         ConstructActionResponseBufferL(i);             

                         }   

                     else                            

                         {  

                         // Constructs a filtered soap response

                         iFilteredAppList->ConstructFilteredGetAppListResponseL(i);

                         }

                     }

                 }

            if ( ( filterStringFound == KErrNotFound ) || ( (iFilteredAppList->SignatureElement()).Length() != KErrNone ))

                {

                // Append the xml signature value to the response buffer if

                // 1. Filter string contains the signature element

                // 2. Filter value is '*'

                AppendDataL(XmlSignature());

                }

            AppendDataL(KAppListEnd);        

            }

        }

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_GETAPPLICATIONLISTL_EXIT );

    return iResponseBuf;

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::LaunchApp

// Method to create soap repsonse for LaunchApp action

// @param aAppId App ID of the application to be launched remotely

// @param aProfileId  ProfileID of client profile 

// @param aUrl[out] URI of the remote application where it is running

// @return Returns Terminal Mode error code

// ---------------------------------------------------------------------------------

//

TTerminalModeErrorCode CUpnpTmServerImpl::LaunchApp( TUint aAppId, TUint aProfileId, 

                                                                       RBuf8& aUrl )    

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_LAUNCHAPP_ENTRY );

    OstTrace1( TRACE_NORMAL, CUPNPTMSERVERIMPL_LAUNCHAPP, "CUpnpTmServerImpl::LaunchApp;aAppId=%d", aAppId );

    TTerminalModeErrorCode err = AuthorizeApp(aAppId);

    if ( err == ETerminalModeSuccess )

        {

        // Launching of the app succeeded

        err = iTmServerObserver.OnLaunchApp( aAppId,aUrl,aProfileId ); 

        }

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_LAUNCHAPP_EXIT );

    return err;

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::TerminateApp

// Method to create soap repsonse for TerminateApp action

// @param aAppId App ID of the application to be terminated

// @param aProfileId  ProfileID of client profile 

// @return Returns Terminal Mode error code

// ---------------------------------------------------------------------------------

//

TTerminalModeErrorCode CUpnpTmServerImpl::TerminateApp( TUint aAppId, TUint aProfileId )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_TERMINATEAPP_ENTRY );

    TTerminalModeErrorCode err = AuthorizeApp(aAppId);

    if ( err == ETerminalModeSuccess )

        {

        // Termination of the app succeeded

        err = iTmServerObserver.OnTerminateApp( aAppId, aProfileId );

        } 

    OstTrace1( TRACE_NORMAL, CUPNPTMSERVERIMPL_TERMINATEAPP, "CUpnpTmServerImpl::TerminateApp;err=%d", err );

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_TERMINATEAPP_EXIT );

    return err;

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::GetAppStatusL

// Method to create soap repsonse for GetAppStatus action

// @param aAppIdBuffer Buffer containing the appID or the wildcard character

// @param aAppStatusResponse[out] soap response buffer 

// @param aErr[out]  Terminal Mode error code

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::GetAppStatusL( const TDesC8& aAppIdBuffer,RBuf8& aAppStatusResponse,

                                                              TTerminalModeErrorCode& aErr )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_GETAPPSTATUSL_ENTRY );

    RArray<TUint> registeredAppIdArray;

    CleanupClosePushL(registeredAppIdArray);

    if ( aAppIdBuffer.Compare( KWildCard()) != KErrNone )

        {

        // If the appID is not wildcard character(*)

        TInt appIdInt(0);

        TLex8 lex( aAppIdBuffer );

        lex.Val(appIdInt);  // No need to check the return code as it has been verified earlier

        aErr = AuthorizeApp( appIdInt );

        if ( aErr != ETerminalModeSuccess )

             {

             CleanupStack::PopAndDestroy(&registeredAppIdArray);

             OstTrace0( TRACE_ERROR, CUPNPTMSERVERIMPL_GETAPPSTATUSL, "CUpnpTmServerImpl::GetAppStatusL" );

             return;  // return if the requested appID is non-existent or un-authorized

             }    

        // add to the array for which get app status has to be retreived

        registeredAppIdArray.AppendL(appIdInt);   

        }

    else

        {

        // Fetch the list of registered apps from the App store

        for ( TInt i(0); i < iAppStore->AppIdArray().Count(); i++ )

            {

            registeredAppIdArray.AppendL(iAppStore->AppIdArray()[i]);       

            }

        }

    iResponseBuf.Close();

    iResponseBuf.CreateL(KActionBufferLength);

    AppendDataL(KAppStatusListStart);

    for ( TInt i(0); i < registeredAppIdArray.Count(); i++ )

        {

        CreateGetAppStatusResponseL( registeredAppIdArray[i], aErr );

        if ( aErr != ETerminalModeSuccess )

            {

            /* Should return an error code if it fails to retrieve the 

               status for even a single application */

            break;

            }         

        }

    AppendDataL(KAppStatusListEnd);

    aAppStatusResponse.CreateL(iResponseBuf);

    CleanupStack::PopAndDestroy(&registeredAppIdArray);

    OstTraceFunctionExit0( DUP2_CUPNPTMSERVERIMPL_GETAPPSTATUSL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::CreateGetAppStatusResponseL

// Helper method for GetApplicationStatus response buffer construction

// @param aAppId AppID

// @param aErr[out]  Terminal Mode error code

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::CreateGetAppStatusResponseL( TUint aAppId,TTerminalModeErrorCode& aErr )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_CREATEGETAPPSTATUSRESPONSEL_ENTRY );

    // Get the app statuses of all the requested apps one by one

    TUint profileId;

    RBuf8 statusType;

    aErr = iTmServerObserver.OnGetAppStatus( aAppId, profileId, statusType);    

    if ( aErr == ETerminalModeSuccess )

       {

       /* Append the status to the buffer only if the fetching of the actual status of the 

          application from the Automotive Server is successful ,else just return the error */

       CleanupClosePushL(statusType);

       AppendDataL(KAppStatusStart);

       AppendDataL(KAppIdStart);

       AppendDataL(ConvertIntToDescriptor(aAppId));

       AppendDataL(KAppIdEnd);

       AppendDataL(KStatusStart);

       AppendDataL(KProfileIdStart);

       AppendDataL(ConvertIntToDescriptor(profileId));

       AppendDataL(KProfileIdEnd);

       AppendDataL(KStatusTypeStart);

       AppendDataL(statusType);

       AppendDataL(KStatusTypeEnd);

       AppendDataL(KStatusEnd);

       AppendDataL(KAppStatusEnd);

       CleanupStack::Pop(&statusType);

       }

    statusType.Close();

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_CREATEGETAPPSTATUSRESPONSEL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::GetMaxNumProfiles

// Method is used to return the value of the state variable MaxNumProfiles, 

// which denotes the maximum number of client profiles that are supported 

// simultaneously by the TmClientProfile service.

// @param aNumMaxProfiles[out] Maximum number of client profiles that are supported 

// @return Returns Terminal Mode error code

// ---------------------------------------------------------------------------------

//

TTerminalModeErrorCode CUpnpTmServerImpl::GetMaxNumProfiles( TUint& aNumMaxProfiles )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_GETMAXNUMPROFILES_ENTRY );

    return iTmServerObserver.OnGetMaxNumProfiles(aNumMaxProfiles);

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::SetClientProfile

// Method to create soap repsonse for SetClientProfile action.

// Method allows the control point to register a client profile and

// notify the Terminal Mode device about its preferences, settings and capabilities.

// @param aProfileId     The identifier of the profile record where the client

//                       profile settings must be stored

// @param aInputClientProfile[out]  Profile information about Terminal Mode client and

//                    its capabilities which needs to be updated in the profile record

// @param aResultProfile[out] The updated client profile.

// @return Returns Terminal Mode error code

// ---------------------------------------------------------------------------------

//

TTerminalModeErrorCode CUpnpTmServerImpl::SetClientProfile( TUint aProfileId, 

                        const TDesC8& aInputClientProfile, RBuf8& aResultProfile )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_SETCLIENTPROFILE_ENTRY );

    return iTmServerObserver.OnSetClientProfile( aProfileId, aInputClientProfile,

                                                                aResultProfile );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::GetClientProfile

// Method to create soap repsonse for GetClientProfile action.

// Method allows the control point to access the contents of a client profile stored 

// in the Terminal Mode device.

// @param aProfileId  The identifier of the profile record where the client 

//                     profile settings must be stored

// @param aClientProfile[out] Client profile corresponding to the profileID input variable

// @return Returns Terminal Mode error code

// ---------------------------------------------------------------------------------

//

TTerminalModeErrorCode CUpnpTmServerImpl::GetClientProfile( TUint aProfileId, RBuf8& aClientProfile )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_GETCLIENTPROFILE_ENTRY );

    return iTmServerObserver.OnGetClientProfile( aProfileId,aClientProfile );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::GetIconInfoL

// Method to fetch the icon file associated with the particular application. 

// @param aUrl Relative URL of the application icon to be retreived

// @param aResultTrans CUpnpHttpServerTransaction object

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::GetIconInfoL( const TDesC8& aUrl, CUpnpHttpServerTransaction*& aResultTrans )

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_GETICONINFOL_ENTRY );

    RBuf svgFilePath;   

    // Fetch the original file path which has been mapped to the requesting file.

    TInt fileIndex = iIconMapping->GetSvgIconPath( aUrl,svgFilePath );

    if ( fileIndex == KErrNotFound )

        {

        // In case the requested icon file is not available, should return EHttpNotFound(404). 

        // Sets the file source as an empty descriptor.

        aResultTrans = CUpnpIconFileServeTransaction::NewL( KNullDesC(), iIconFileSession );  

        svgFilePath.Close();

        OstTraceFunctionExit0( CUPNPTMSERVERIMPL_GETICONINFOL_EXIT );

        return;

        }

    CleanupClosePushL(svgFilePath);

    /* Extracts the profileID from the relative URL.

     * The relative URL will be of the form ( /<profileID>/<iconName> )

     */

    const TDesC8& urlWithoutLeadingSlash = aUrl.Mid((aUrl.Locate(KForwardSlash))+1);

    TInt secondSlashPos = urlWithoutLeadingSlash.Locate(KForwardSlash);

    User::LeaveIfError(secondSlashPos);

    const TDesC8& profileIdBuf = urlWithoutLeadingSlash.Left(secondSlashPos);

    // Converts descriptor to int

    TLex8 lex( profileIdBuf );

    TUint profileIdInt(KErrNone);

    lex.Val(profileIdInt);

    // Fetch the reference to client icon preference object from AutomotiveServer

    const CUpnpTmClientIconPref& clientIconPref = iTmServerObserver.GetClientIconPrefsL(profileIdInt);

    TInt servingIconWidth(KErrNone);

    TInt servingIconHeight(KErrNone);

    /* 

     * Checks whether the conversion of the icon file needed.

     * If conversion is required, it also determines the dimension(width and height) 

     * of the serving file.

     */ 

    TBool iconConversionNeeded = iIconMapping->IsConversionNeeded( fileIndex, clientIconPref, servingIconWidth,servingIconHeight );

    if ( iconConversionNeeded )

        {

        // Icon file conversion is needed( svg to bmp )

        CUpnpSvgImageConverter* decoder = CUpnpSvgImageConverter::NewL( servingIconWidth, servingIconHeight );

        CleanupStack::PushL(decoder);

        RBuf bitmapBuf;

        CleanupClosePushL(bitmapBuf);

        decoder->ConvertToBitmapL( svgFilePath, bitmapBuf );  // Method which in turn invokes the conversion

        aResultTrans = CUpnpIconFileServeTransaction::NewL( bitmapBuf, iIconFileSession ); /* Sets the data source( file ) 

                                                                                           which needs to be serverd*/

        CleanupStack::PopAndDestroy( 2,decoder);

        }

    else

        {

        // No icon file conversion needed ( svg icon is served )

        aResultTrans = CUpnpIconFileServeTransaction::NewL( svgFilePath, iIconFileSession );

        }

    CleanupStack::PopAndDestroy(&svgFilePath);

    OstTraceFunctionExit0( DUP1_CUPNPTMSERVERIMPL_GETICONINFOL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::StartDeviceL

// Method is used to start publishing the terminal mode server device and 

// its services

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::StartDeviceL()

    {

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_STARTDEVICEL_ENTRY );

    iTmServerDevice->StartTmServerDeviceL();

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_STARTDEVICEL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::StopDeviceL

// Method is used to stop publishing the terminal mode server device and 

// its services

// ---------------------------------------------------------------------------------

//

void CUpnpTmServerImpl::StopDeviceL()

    {   

    OstTraceFunctionEntry0( CUPNPTMSERVERIMPL_STOPDEVICEL_ENTRY );

    iTmServerDevice->StopTmServerDeviceL();

    OstTraceFunctionExit0( CUPNPTMSERVERIMPL_STOPDEVICEL_EXIT );

    }

// ---------------------------------------------------------------------------------

// CUpnpTmServerImpl::GetRemotableApp

// Method is invoked by the Automotive Server to get the access to the particular

// instance of the remotable app corresponding to the app ID provided.

// This is needed in case AS wishes to modify any paramters of the already 

// registered remotable app

// @param aAppId App ID of the application whose access is needed

// @param aErr[out]  Error code

// @returns Returns reference to the Remotable App object

// ---------------------------------------------------------------------------------

//