/*******************************************************************************
 * Copyright (c) 2009, 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Nokia Corporation - initial implementation
 *******************************************************************************/

#include <apgtask.h>
#include <hbdevicenotificationdialogsymbian.h>
#include <hbsymbianvariant.h>

#include <memory>
#include <javastorageentry.h>
#include <javastorage.h>
#include <javastoragenames.h>
#include <JavaCommonUtils.h>
#include <logger.h>

#include "CSoftNotification.h"

_LIT(KMidletId, "MidletId");
_LIT(KNotificationId, "NotificationId");
_LIT(KIndicatorTypeJavaSoftNote,"com.nokia.javasoftnotification.indicatorplugin/1.0_%u_%i");
const TInt KIndicatorTypeStringLength = 250;
const TInt KMidletUidLength = 50;

// Event id when user accepted notification
const TInt KEventNoteAccepted = 1;

using namespace std;
using namespace java::storage;
using namespace java::util;

// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CSoftNotification::NewLC
// Static constructor
// -----------------------------------------------------------------------------
//
CSoftNotification* CSoftNotification::NewL(TInt aAppId, TInt aNotificationId)
    {
    CSoftNotification* self = new (ELeave) CSoftNotification(aAppId,
            aNotificationId);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::CSoftNotification
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSoftNotification::CSoftNotification(TInt aAppId, TInt aNotificationId) :
    iNotificationId(aNotificationId),iIsNoteExist(EFalse)
    {
    iMidletId = TUid::Uid(aAppId);
    }

// -----------------------------------------------------------------------------
// CSoftNotification::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSoftNotification::ConstructL()
    {
    std::auto_ptr<JavaStorage> js(JavaStorage::createInstance());
    TInt maxValue = 0;
    try
        {
        js->open(JAVA_DATABASE_NAME);
        JavaStorageEntry attribute;
        JavaStorageApplicationEntry_t findPattern;
        JavaStorageApplicationList_t foundEntries;

        std::wstring midletId = JavaCommonUtils::intToWstring(iMidletId.iUid);
        attribute.setEntry(SOFTNOTE_MIDLET_ID, midletId);
        findPattern.insert(attribute);

        js->search(JAVA_SOFTNOTE_TABLE, findPattern, foundEntries);
        js->close();
        findPattern.clear();

        // like to know softnote id.
        attribute.setEntry(SOFTNOTE_ID, L"");
        // Iterate through all rows matched with search patterns.
        JavaStorageApplicationList_t::const_iterator applications;
        for(applications = foundEntries.begin(); applications !=foundEntries.end(); applications++)
            {
            // Get softnote ID from its parameters.
            JavaStorageApplicationEntry_t::const_iterator findIterator = (*applications).find(attribute);
            if (findIterator != (*applications).end())
                {
                TInt id = JavaCommonUtils::wstringToInt((*findIterator).entryValue());
                if(iNotificationId == id)
                    {
                    iIsNoteExist = true;
                    }
                if(maxValue<id)
                    {
                    maxValue = id;
                    }
                }
            }
        foundEntries.clear();
        }
    catch (JavaStorageException& ex)
        {
        LOG1(EJavaStorage, EInfo," JavaSoftNote Exception %S", ex.toString().c_str());
        }
    
    if(!iIsNoteExist && iNotificationId == 0)
        {
        iNotificationId = maxValue + 1;
        }
    if(iIndicator == NULL)
        {
        iIndicator = CHbIndicatorSymbian::NewL();
        iIndicator->SetObserver(this);
        }
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CSoftNotification::~CSoftNotification()
    {
    if (iPrimaryText)
        {
        delete iPrimaryText;
        }
    
    if (iSecondaryText)
        {
        delete iSecondaryText;
        }
    
    if (iImagePath)
        {
        delete iImagePath;
        }
    
    if (iIndicator)
        {
        delete iIndicator;
        }
    
    if(iNotificationDialog)
        {
        delete iNotificationDialog;
        }
    
    if (iPeer)
        {
        iJniEnv->DeleteWeakGlobalRef((jweak)iPeer);
        }
    
    iPrimaryText = NULL;
    iSecondaryText = NULL;
    iImagePath = NULL;
    iIndicator = NULL;
    iNotificationDialog = NULL;
    iPeer = NULL;
    iMethodId = NULL;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::ShowSoftNotificationL
// Displays a soft notification
// -----------------------------------------------------------------------------
//
bool CSoftNotification::ShowSoftNotificationL()
    {
    AddorUpdateSoftNotificationToStorage();
    
    if(iNotificationDialog == NULL)
        {
        iNotificationDialog = CHbDeviceNotificationDialogSymbian::NewL(this);
        }
    
    if(iPrimaryText != NULL)
        {
        iNotificationDialog->SetTitleL(iPrimaryText->Des());
        }

    if(iSecondaryText != NULL)
        {
        iNotificationDialog->SetTextL(iSecondaryText->Des());
        }
    
    if (iImagePath != NULL)
        {
        iNotificationDialog->SetIconNameL(iImagePath->Des());
        }
    iNotificationDialog->EnableTouchActivation(ETrue);
    iNotificationDialog->ShowL();
  
    // reading Softnote data
    CHbSymbianVariant* varValues = NotificationParamsL();
    CleanupStack::PushL(varValues);
    
    // creating indicator in status menu
    TBuf<KIndicatorTypeStringLength> indicatorType;
    indicatorType.Format(KIndicatorTypeJavaSoftNote, iMidletId, iNotificationId);
    bool indStatus = iIndicator->Activate(indicatorType, varValues);
    
    CleanupStack::PopAndDestroy(varValues);
    return indStatus;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::RemoveSoftNotificationL
// Cancels and removes the soft notification
// -----------------------------------------------------------------------------
//
void CSoftNotification::RemoveSoftNotificationL()
    {
    TBuf<KIndicatorTypeStringLength> type;
    type.Format(KIndicatorTypeJavaSoftNote, iMidletId, iNotificationId);
    iIndicator->Deactivate(type);
    }

// -----------------------------------------------------------------------------
// CSoftNotification::SetTextL
// Sets a text for a soft notification
// -----------------------------------------------------------------------------
//
void CSoftNotification::SetTextL(const TDesC& aPrimaryText, const TDesC& aSecondaryText)
    {
    HBufC* txt = aPrimaryText.AllocL();
    delete iPrimaryText;
    iPrimaryText = txt;

    txt = aSecondaryText.AllocL();
    delete iSecondaryText;
    iSecondaryText = txt;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::SetImagePathL
// Sets a text for a soft notification
// -----------------------------------------------------------------------------
//
void CSoftNotification::SetImagePathL(const TDesC& aImagePath)
    {
    HBufC* txt = aImagePath.AllocL();
    delete iImagePath;
    iImagePath = txt;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::Id
// Notification Id
// -----------------------------------------------------------------------------
//
TInt CSoftNotification::Id()
    {
    return iNotificationId;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::SetPeerObserverL
// -----------------------------------------------------------------------------
//
void CSoftNotification::SetPeerObserver(jobject aPeer, jmethodID aMethodId,
        JNIEnv* aJniEnv)
    {
    iJniEnv = aJniEnv;
    iPeer = aPeer;
    iMethodId = aMethodId;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::IndicatorUserActivated
// Dynamic soft notification was accepted by user.
// -----------------------------------------------------------------------------
//
void CSoftNotification::IndicatorUserActivated(const TDesC& /*aType*/,
        CHbSymbianVariantMap &aData)
    {
    TInt notificationId = *reinterpret_cast<const TInt*>(aData.Get(KNotificationId)->Data());
    TUid midletId(TUid::Uid(*reinterpret_cast<const TUint*>(aData.Get(KMidletId)->Data())));
    if (iPeer && iMidletId == midletId &&
        iNotificationId == notificationId )
        {
        // Can't attempt callback if JVM is processing an exception. Event is
        // possibly lost by Java listener.
        if (iJniEnv->ExceptionCheck() == JNI_TRUE)
            {
            return;
            }
        if (iMethodId)
            {
            iJniEnv->CallVoidMethod(iPeer, iMethodId, KEventNoteAccepted);
            }
        }
    }

// -----------------------------------------------------------------------------
// CSoftNotification::NotificationDialogActivated
// Dynamic soft notification was accepted by user.
// -----------------------------------------------------------------------------
//
void CSoftNotification::NotificationDialogActivated(const CHbDeviceNotificationDialogSymbian* /*aDialog*/)
  {
    RWsSession ws;
    User::LeaveIfError(ws.Connect() == KErrNone);
    TApaTaskList tasklist(ws);
    TApaTask task = tasklist.FindApp(iMidletId);
    if (task.Exists())
        {
        task.BringToForeground();
        ws.Close();
        }
    }

// -----------------------------------------------------------------------------
// CSoftNotification::NotificationDialogClosed
// Dynamic soft notification was closed.
// -----------------------------------------------------------------------------
//
void CSoftNotification::NotificationDialogClosed(const CHbDeviceNotificationDialogSymbian* /*aDialog*/,
        TInt /*aCompletionCode*/)
    {
    
    }

// -----------------------------------------------------------------------------
// CSoftNotification::FillNotificationParams
// -----------------------------------------------------------------------------
//
CHbSymbianVariant* CSoftNotification::NotificationParamsL()
    {
    //only five parameter, so creat the array with size 5.
    CDesC16ArrayFlat* array = new CDesC16ArrayFlat(5);
    CleanupStack::PushL(array);
    TBuf<KMidletUidLength> midletId;
    _LIT(MidletId,"%u");
    midletId.Format(MidletId,iMidletId);
    array->AppendL(midletId);
    
    TBuf<10> noteId;
    _LIT(NoteId,"%d");
    noteId.Format(NoteId,iNotificationId);
    array->AppendL(noteId);

    if(iPrimaryText != NULL)
        {
        array->AppendL(iPrimaryText->Des());
        }
    else
        {
        array->AppendL(KNullDesC);
        }
    
    if(iSecondaryText != NULL)
        {
        array->AppendL(iSecondaryText->Des());
        }
    else
        {
        array->AppendL(KNullDesC);
        }
    
    if (iImagePath != NULL)
        {
        array->AppendL(iImagePath->Des());
        }
    else
        {
        array->AppendL(KNullDesC);
        }
    MDesCArray* marray = static_cast<MDesCArray*>(array);
    CHbSymbianVariant* varValues = CHbSymbianVariant::NewL( marray, CHbSymbianVariant::EDesArray);
    CleanupStack::PopAndDestroy(array);
    return varValues;
    }

// -----------------------------------------------------------------------------
// CSoftNotification::AddSoftNotificationToStorage
// -----------------------------------------------------------------------------
//
void CSoftNotification::AddorUpdateSoftNotificationToStorage()
    {
    std::auto_ptr<JavaStorage> js(JavaStorage::createInstance());
    try
        {
        js->open(JAVA_DATABASE_NAME);
        JavaStorageApplicationEntry_t newEntries;
        JavaStorageApplicationEntry_t matchEntries;
        JavaStorageEntry attribute;

        if (!iIsNoteExist)
            {
            // if Softnote is not created, add midletId and notificationId to storage
            std::wstring midletId = JavaCommonUtils::intToWstring(
                    iMidletId.iUid);
            attribute.setEntry(SOFTNOTE_MIDLET_ID, midletId,
                    JavaStorageEntry::STRING);
            newEntries.insert(attribute);

            std::wstring notificationId = JavaCommonUtils::intToWstring(
                    iNotificationId);
            attribute.setEntry(SOFTNOTE_ID, notificationId,
                    JavaStorageEntry::INT);
            newEntries.insert(attribute);
            }
        else
            {
            // if Softnote is already in the storage, just aupdate the data.
            std::wstring midletId = JavaCommonUtils::intToWstring(
                    iMidletId.iUid);
            attribute.setEntry(SOFTNOTE_MIDLET_ID, midletId,
                    JavaStorageEntry::STRING);
            matchEntries.insert(attribute);

            std::wstring notificationId = JavaCommonUtils::intToWstring(
                    iNotificationId);
            attribute.setEntry(SOFTNOTE_ID, notificationId,
                    JavaStorageEntry::INT);
            matchEntries.insert(attribute);
            }

        if (iPrimaryText)
            {
            std::wstring primaryText((wchar_t*) iPrimaryText->Ptr(),
                    iPrimaryText->Length());
            attribute.setEntry(SOFTNOTE_PRIMARY_TEXT, primaryText,
                    JavaStorageEntry::STRING);
            newEntries.insert(attribute);
            }
        if (iSecondaryText)
            {
            std::wstring secondaryText((wchar_t*) iSecondaryText->Ptr(),
                    iSecondaryText->Length());
            attribute.setEntry(SOFTNOTE_SECONDARY_TEXT, secondaryText,
                    JavaStorageEntry::STRING);
            newEntries.insert(attribute);
            }
        if (iImagePath)
            {
            std::wstring imagePath((wchar_t*) iImagePath->Ptr(),
                    iImagePath->Length());
            attribute.setEntry(SOFTNOTE_IMAGE_PATH, imagePath,
                    JavaStorageEntry::STRING);
            newEntries.insert(attribute);
            }

        if (!iIsNoteExist)
            {
            // create new entry in storage if softnote is not created earlier
            js->write(JAVA_SOFTNOTE_TABLE, newEntries);
            }
        else
            {
            // update data for softNote. 
            js->update(JAVA_SOFTNOTE_TABLE, newEntries, matchEntries);
            }
        js->close();
        newEntries.clear();
        matchEntries.clear();
        }
    catch (JavaStorageException& ex)
        {
        LOG1(EJavaStorage, EInfo," JavaSoftNote Exception %S", ex.toString().c_str());
        }
    }