/*

* Copyright (c) 2008 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:  This file contains an implementation of Symbian MIME type recognizer

 *                for MIME types application/java-archive (.jar) and

 *                text/vnd.sun.j2me.app-descriptor (.jad)

 *

*/

#include <apmrec.h>

#include <apmstd.h>

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include "javauids.h"

#include "recjar.h"

const TUid KJavaRecognizerTUid = { KJavaRecognizerDllUid};

const TInt KJarNumMimeTypes = 2;

const TInt KMaxBufferLength = 100;

_LIT8(KDataTypeJavaArchive, "application/java-archive");

_LIT8(KDataTypeAppDescriptor, "text/vnd.sun.j2me.app-descriptor");

// First four bytes of a ZIP file

_LIT8(KPkWareLocalFileHeader, "\x50\x4B\x03\x04");

_LIT8(KMidlet,"Midlet-");

CApaJarRecognizer::CApaJarRecognizer() :

        CApaDataRecognizerType(KJavaRecognizerTUid, CApaDataRecognizerType::EHigh)

{

    iCountDataTypes = KJarNumMimeTypes;

}

TUint CApaJarRecognizer::PreferredBufSize()

{

    return KMaxBufferLength;

}

TDataType CApaJarRecognizer::SupportedDataTypeL(TInt aIndex) const

{

    __ASSERT_DEBUG(aIndex >= 0 && aIndex < KJarNumMimeTypes, User::Invariant());

    switch (aIndex)

    {

    case 0:

        return TDataType(KDataTypeJavaArchive);

    case 1:

        return TDataType(KDataTypeAppDescriptor);

    default:

        // Should not come here, keep GCC happy

        return TDataType(KDataTypeJavaArchive);

    }

}

void CApaJarRecognizer::DoRecognizeL(const TDesC& aName, const TDesC8& aBuffer)

{

    if (aName.Length() > 4)

    {

        if (aName.Right(4).CompareF(_L(".jad")) == 0)

        {

            if (aBuffer.Length() > 0 && aBuffer.FindF(KMidlet())

                    != KErrNotFound)

            {

                // The file contains the text "midlet-"

                // so its almost certain to be a JAD file

                iDataType = TDataType(KDataTypeAppDescriptor);

                iConfidence = ECertain;

            }

            else

            {

                // Did not find "midlet-" in the supplied buffer so

                // try searching the rest of the file...

                //

                TBool weOwnFileHandle = EFalse;

                // The following call only Leaves if user supplied file

                // handle can not be rewound, this is not worth

                // catching with a TRAP handler.

                RFile *file = FilePassedByHandleL();

                RFile ownFile;

                RFs ownFs;

                if (!file)

                {

                    // We were not passed an RFile, so try and open the file directly.

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

                    CleanupClosePushL(ownFs);

                    User::LeaveIfError(ownFile.Open(ownFs, aName, EFileRead

                                                    | EFileShareReadersOrWriters | EFileStream));

                    CleanupClosePushL(ownFile);

                    file = &ownFile;

                    weOwnFileHandle = ETrue;

                }

                User::LeaveIfError(file->Size(fileRemaining));

                if (fileRemaining > aBuffer.Length())

                {

                    // File is longer than buffer, so search remainder

                    // of file.

                    // Skip the start, which has already been read

                    TInt tmp = aBuffer.Length();

                    User::LeaveIfError(file->Seek(ESeekStart, tmp));

                    fileRemaining -= tmp;

                    // Buffer for processing the file

                    TUint8 buf[100]; // Must be at least 2*(KMidlet.Length()-1)

                    // Copy up to the last KMidlet.Length()-1 bytes

                    // from aBuffer, then append file data. This

                    // handles the case where the KMidlet string

                    // straddles the boundry by a byte (eg. buffer

                    // ends with "Midlet" and we are looking for

                    // "Midlet-").

                    TInt prefixLength = KMidlet().Length() - 1;

                    if (aBuffer.Length() < prefixLength)

                    {

                        prefixLength = aBuffer.Length();

                    }

                    TInt prefixOffset = aBuffer.Length() - prefixLength;

                    if (prefixOffset < 0)

                    {

                        prefixOffset = 0;

                    }

                    if (prefixLength)

                    {

                        // Copy prefix into buffer

                        TPtr8 prefixDes(&buf[0], prefixLength);

                        prefixDes = aBuffer.Mid(prefixOffset, prefixLength);

                    }

                    while (fileRemaining > 0)

                    {

                        // Read as much file data into the buffer as possible.

                        TPtr8 bufBodyDes(&buf[0] + prefixLength, sizeof(buf)

                                         - prefixLength);

                        User::LeaveIfError(file->Read(bufBodyDes));

                        fileRemaining -= bufBodyDes.Length();

                        TPtrC8 bufDes(&buf[0], prefixLength

                                      + bufBodyDes.Length());

                        if (bufDes.FindF(KMidlet()) != KErrNotFound)

                        {

                            // The file contains the text "midlet-"

                            // so its almost certain to be a JAD file

                            iDataType = TDataType(KDataTypeAppDescriptor);

                            iConfidence = ECertain;

                            break;

                        }

                        // Not found, copy prefix to start of buffer and try again.

                        if (bufDes.Length() == sizeof(buf))

                        {

                            // Copy prefix into buffer

                            prefixLength = KMidlet().Length() - 1;

                            TPtr8 prefixDes(buf, prefixLength);

                            prefixDes = bufDes.Mid(bufDes.Length()

                                                   - prefixLength, prefixLength);

                        }

                    }

                }

                if (weOwnFileHandle)

                {

                    CleanupStack::PopAndDestroy(&ownFile);

                    CleanupStack::PopAndDestroy(&ownFs);

                }

            }

        }

        else if (aName.Right(4).CompareF(_L(".jar")) == 0)

        {

            // if the first 4 bytes of the buffer match the first 4

            // bytes of a zip file it must be a JAR file

            if (aBuffer.Length() > KPkWareLocalFileHeader().Length()

                    && KPkWareLocalFileHeader().Compare(aBuffer.Left(4)) == 0)

            {

                iDataType = TDataType(KDataTypeJavaArchive);

                iConfidence = ECertain;

            }

        }

    }

    return;

}

CApaDataRecognizerType* CApaJarRecognizer::CreateRecognizerL()

{

    return new(ELeave) CApaJarRecognizer();

}

const TImplementationProxy ImplementationTable[] =

{

    IMPLEMENTATION_PROXY_ENTRY(KRecognizerEcomImplUid, CApaJarRecognizer::CreateRecognizerL)

};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

{

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

}