// Copyright (c) 2003-2009 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:

// SmsWatcher.CPP

//

#include <e32std.h>

#include <biouids.h>

#include <c32comm.h>

#include <smut.h>

#include "SmsWatcher.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include "cwatcher.h"

#endif

const TInt KAllBioUids = 0;

EXPORT_C CSmsBaseWatcher::CSmsBaseWatcher(RFs& aFs, CWatcherLog& aLog, TInt aPriority)

: CActive(aPriority), iFs(aFs), iWatcherLog(aLog)

	{

	CActiveScheduler::Add(this);

	}

//

// Construction/destruction

EXPORT_C void CSmsBaseWatcher::ConstructL()

	{

	// The session to the message server is created in the ConstructL because at this 

	// moment the message server still runs because of the open session in CWatcherLauncherArray

	// If we would open the session in StartL, the message server will be opened and closed  

	// several times, which has a negative effect on performance.

	iSession = CMsvSession::OpenSyncL(*this);

	User::LeaveIfError(iTimer.CreateLocal());

	ConstructDbL();

	CompleteMyself(KErrNone);

	}

EXPORT_C void CSmsBaseWatcher::StartL()

	{

	// put the real construction here

	iSocketWatchers = new (ELeave) CArrayPtrFlat<CBaseSmsActiveSocketWatcher>(10);

	// Hook into the Bif Change Observer

	iBifObserver = CBifChangeObserver::NewL(*this, iFs);

	iBifObserver->Start();

	}

//

// Construction/destruction

EXPORT_C CSmsBaseWatcher::~CSmsBaseWatcher()

	{

	Cancel();

	Reset();

	ResetDb();

	iTimer.Close();

	delete iSession;

	}

EXPORT_C void CSmsBaseWatcher::Reset()

	{

	__ASSERT_DEBUG(!IsActive(), PanicWatcher(ESocketWatcherAlreadyActive));

	if (iSocketWatchers)

		iSocketWatchers->ResetAndDestroy();

	delete iSocketWatchers;

	iSocketWatchers = NULL;

	delete iBifObserver;

	iBifObserver = NULL;

	//Do not close iTimer. Leave that for the destructor.

	}

//

EXPORT_C void CSmsBaseWatcher::HandleBifChangeL(TBifChangeEvent aEvent, TUid aBioID)

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: Watcher HandleBifChangeL(Event: %d, BioUid: %d)"), aEvent, aBioID.iUid));

	TInt err = KErrNone;

	switch(aEvent)

		{

		case EBifAdded:

			TRAP(err, AddBifL(aBioID));

			break;

		case EBifDeleted:

			TRAP(err, DeleteBifL(aBioID));

			break;

		case EBifChanged:

			TRAP(err, ReloadBifL(aBioID));

			break;

		default:

			break;

		} 

	if (err)

		{

		BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: Watcher HandleBifChangeL(Event: %d, BioUid: %d) error: %d"), aEvent, aBioID.iUid, err));

		}

	}

EXPORT_C void CSmsBaseWatcher::RunL()

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: Attempting restart [iStatus=%d]"), iStatus.Int()));

	//Restart the watcher

	Reset();

	StartL();

	}

EXPORT_C void CSmsBaseWatcher::DoCancel()

	{

	iTimer.Cancel();

	}

EXPORT_C void CSmsBaseWatcher::HandleWatcherComplete(CBaseSmsActiveSocketWatcher& aWatcher, TInt aError)

	{

	//Only try to re-start the watcher if it wasn't cancelled.

	if (!iSocketWatchers || aError == KErrCancel)

		return;

	TInt count = iSocketWatchers->Count();

	TInt err = KErrNone;

	while (count--)

		{

		CBaseSmsActiveSocketWatcher* watcher = iSocketWatchers->At(count);

		if (watcher == &aWatcher)

			{

			//Found the same watcher

			TRAP(err, watcher->SetupL());

			if (!err)

				{

				TRAP(err, watcher->StartL());

				}

			if (err)

				{

				iSocketWatchers->Delete(count);

				delete watcher;

				}

			break;

			}

		}

	if (err)

		{

		//This will call RunL, which will restart the watcher.

		BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: Unable to restart watcher [err=%d, IsActive=%d]"), err, IsActive()));

		Cancel();

		iTimer.After(iStatus, KWatcherDelay);

		SetActive();

		}

	}

EXPORT_C void CSmsBaseWatcher::DeleteSocketWatchersWithUidL(TUid aUid)

	{

	TInt count = iSocketWatchers->Count();

	while (count--)

		{

		CBaseSmsActiveSocketWatcher* socketWatcher = iSocketWatchers->At(count);

		if (socketWatcher->BioMsgUID() == aUid)

			{

			socketWatcher->Cancel();

			delete socketWatcher;

			iSocketWatchers->Delete(count);

			}

		}

	}

EXPORT_C void CSmsBaseWatcher::CreateSocketWatchersFromBioDbL(TBioMsgIdType aType)

	{

	CreateSocketWatchersFromBioDbL(aType, *iSocketWatchers);

	}

void CSmsBaseWatcher::CreateSocketWatchersFromBioDbL(TBioMsgIdType aType, CArrayPtrFlat<CBaseSmsActiveSocketWatcher>& rSocketWatchers)

	{

	TUid uid;

	uid.iUid = KAllBioUids;

	CreateSocketWatchersFromBioDbL(aType, uid, rSocketWatchers);

	}

EXPORT_C void CSmsBaseWatcher::CreateSocketWatchersFromBioDbL(TBioMsgIdType aType, TUid aBioID)

	{

	CreateSocketWatchersFromBioDbL(aType, aBioID, *iSocketWatchers);

	}

void CSmsBaseWatcher::CreateSocketWatchersFromBioDbL(TBioMsgIdType aType, TUid aUid, CArrayPtrFlat<CBaseSmsActiveSocketWatcher>& rSocketWatchers)

	{

	ConstructDbL();

	TInt pos;

	TUid bioMsgID(KNullUid);

	CBaseSmsActiveSocketWatcher* socketWatcher = NULL;

	const CArrayFix<TBioMsgId>* bioIDs = iBioDb->BioEntryByTypeLC(CBIODatabase::EStart, aType, pos);

	if (bioIDs)

		iBioDb->GetBioMsgID(pos, bioMsgID);

	TInt bioDBCount = iBioDb->BIOCount();

	while( bioIDs != 0 || pos < bioDBCount )

		{

		if (aUid.iUid == KAllBioUids || bioMsgID == aUid)

			{

			TInt index = 0;

			if (bioIDs)

				{

				index = bioIDs->Count();

				}

			while (index--)

				{

				// Create the Socket Watcher and Add it to the list

				TBioMsgId msgId = bioIDs->At(index);

				if (msgId.iType == aType && SupportBioMsgId(msgId))

					{

					socketWatcher = CreateSocketWatcherLC(bioMsgID, msgId);

					TInt error = SetupAndAppendL(*socketWatcher, rSocketWatchers);

					if (error)

						CleanupStack::PopAndDestroy();

					else

						CleanupStack::Pop();

					}

				}

			}

		CleanupStack::PopAndDestroy();	// bioIDs

		bioIDs = NULL;

		bioIDs = iBioDb->BioEntryByTypeLC(CBIODatabase::ENext, aType, pos);

		if (bioIDs)

			iBioDb->GetBioMsgID(pos, bioMsgID);

		}

	}

EXPORT_C void CSmsBaseWatcher::StartSocketWatchersL()

	{

	StartSocketWatchersL(*iSocketWatchers);

	}

void CSmsBaseWatcher::StartSocketWatchersL(const CArrayPtrFlat<CBaseSmsActiveSocketWatcher>& aSocketWatchers)

	{

	TInt count = aSocketWatchers.Count();

	//Order Important

	for (TInt i = 0; i < count; i++)

		{

		CBaseSmsActiveSocketWatcher* socketWatcher = aSocketWatchers[i];

		socketWatcher->SetObserver(this);

		socketWatcher->StartL();

		}

	}

EXPORT_C void CSmsBaseWatcher::DeleteBifL(TUid aBioID)

	{

	DeleteSocketWatchersWithUidL(aBioID);

	}

EXPORT_C void CSmsBaseWatcher::ReloadBifL(TUid aBioID)

	{

	DeleteBifL(aBioID);

	AddBifL(aBioID);

	}

EXPORT_C void CSmsBaseWatcher::AddBifWithTypeL(TBioMsgIdType aType, TUid aBioID)

	{

	CArrayPtrFlat<CBaseSmsActiveSocketWatcher>* socketWatchers = new (ELeave) CArrayPtrFlat<CBaseSmsActiveSocketWatcher>(1);

	CleanupStack::PushL(socketWatchers);

	CreateSocketWatchersFromBioDbL(aType, aBioID, *socketWatchers);

	StartSocketWatchersL(*socketWatchers);

	TInt count = socketWatchers->Count();

	while (count--)

		{

		iSocketWatchers->AppendL(socketWatchers->At(count));

		}

	CleanupStack::PopAndDestroy(); //socketWatchers

	}

EXPORT_C TInt CSmsBaseWatcher::SetupAndAppendL(CBaseSmsActiveSocketWatcher& aSocketWatcher, CArrayPtrFlat<CBaseSmsActiveSocketWatcher>& rSocketWatchers)

	{

	TRAPD(error, aSocketWatcher.SetupL());

	if (!error)

		{

		rSocketWatchers.AppendL(&aSocketWatcher);

		}

	else 

		{

		BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: Watcher setup error - %d"), error));

		if (error != KErrAlreadyExists && error != KErrNotFound)

			User::Leave(error);

		else

			BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: Ignoring watcher error - Config problem?")));

		}

	return error;

	}

void CSmsBaseWatcher::ConstructDbL()

	{

	if (iBioDb == NULL)

		iBioDb = CBIODatabase::NewL(iFs);

	}

EXPORT_C void CSmsBaseWatcher::ResetDb()

	{

	delete iBioDb;

	iBioDb = NULL;

	}

EXPORT_C void CSmsBaseWatcher::CompleteMyself(TInt aError)

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, aError);

	SetActive();

	}

EXPORT_C TInt CSmsBaseWatcher::RunError(TInt aError)

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: RunL left with %d. Restarting in %d sec"), aError, KWatcherDelay / 1000000));

	iTimer.After(iStatus, KWatcherDelay);

	SetActive();

	return KErrNone;

	}

EXPORT_C void CSmsBaseWatcher::GetBioServiceId(CMsvSession& aSession, TMsvId& aBioServiceId, TMsvId& aSmsServiceId)

	{

	TInt err = KErrNone;

	TRAP(err, TSmsUtilities::ServiceIdL(aSession, aBioServiceId, KUidBIOMessageTypeMtm));

	if (err == KErrNotFound)

		{

		aBioServiceId = KMsvLocalServiceIndexEntryId;

		}

	TRAP(err, TSmsUtilities::ServiceIdL(aSession, aSmsServiceId));

	if (err == KErrNotFound)

		{

		aSmsServiceId = KMsvLocalServiceIndexEntryId;

		}

	}