// TBACKCLI.CPP
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//

#include "e32std.h"
#include <f32file.h>
#include "e32svr.h"
//
#include <PlpBakMs.h>
//
#include "TBackCli.h"
//


CBackupClient *CBackupClient::NewL(MBackupObserver *anObserver)
	{
	CBackupClient * bc= new(ELeave) CBackupClient(anObserver);
	CleanupStack::PushL(bc);
	bc->ConstructL();
	CleanupStack::Pop();
	return bc;
	}

CBackupClient::CBackupClient(MBackupObserver *anObserver)
:CActive(EPriorityNormal), iObserver(anObserver)
	{
	}

CBackupClient::~CBackupClient()
	{
	Cancel();
	iClient.Close();
	}

void CBackupClient::ConstructL()
	{
	TVersion v(KBakMajorVN, KBakMinorVN, KBakBuildVN);
	User::LeaveIfError(iClient.CreateSession(__BACKUP_SERVER_NAME, v, 1));
	CActiveScheduler::Add(this);
	}

void CBackupClient::ListOpenFilesL()
	{
	if (iState!=EStateIdle)
		User::Leave(KErrNotReady);
	//
	iState=EStateListOpenFiles;
	//
	if(iArray)
		delete iArray;
	iArray=new(ELeave)CDesCArrayFlat(10);
	//
	TUint32 h=0;
	TInt r=iClient.DocumentListOpen(h);
	if (r)
		{
		iState=EStateIdle;
		User::Leave(r);
		}
	TFileName Doc, App;
	TInt id;
	while(iClient.DocumentListRead(h, App, Doc, id)==KErrNone)
		{
		iArray->AppendL(Doc);
		}
	iClient.DocumentListClose(h);
	//
	if(iObserver->OnListOpenFiles(KErrNone, iArray)==EFalse)
		delete iArray; // taken by control ??
	iArray=0;	
	iState=EStateIdle;
	}

void CBackupClient::StopDocumentL(const TDesC &aDocument)
	{
	if (iState!=EStateIdle)
		User::Leave(KErrNotReady);

	if(!aDocument.Length())
		{
		iObserver->OnStopDocument(KErrNotReady);
		return;
		}
	//
	iState=EStateStopDoc;
	TInt r=iClient.DocumentIsOpen(aDocument);
	if(r==KErrNone)
		r=iClient.DocumentStop(aDocument);
	User::After(1000000);
	r=iClient.DocumentStart(aDocument);
    User::After(1000000);

	TFileName doc, app;
	TInt id=0;
	if(r==KErrNone)
		{

		TUint32 h=0;
        r=iClient.DocumentListOpen(h);
		if(r==KErrNone)
			{
			while(iClient.DocumentListRead(h, app, doc, id)==KErrNone)
				{
				if(!doc.CompareF(aDocument))
					break;
				else
					id=0;
				}
			}
		r=iClient.DocumentListClose(h);
		r=iClient.DocumentListClose(104);
		}
	if(id)
		{
		r=iClient.AppIsRunning(app, id);
		TFileName docname, dll;
		if(r==KErrNone)
			{
			r=iClient.DetailsFromApp(app, id, dll, docname);
			}	

		if(r==KErrNone)
			{
			r=iClient.AppStop(app, id);
			User::After(1000000);
			}
		if(r==KErrNone)
			{
			TCommand command;
			command.Append(dll);
			command.Append(_L(" "));
			command.Append(docname);
			r=iClient.AppStart(command);
			User::After(1000000);
			}
		}

	iState=EStateIdle;
	//
	iObserver->OnStopDocument(r);
	}
void CBackupClient::CheckDocumentL(const TDesC &aDocument)
	{
	if (iState!=EStateIdle)
		User::Leave(KErrNotReady);
	//
	iState=EStateCheckDoc;
	TInt r=iClient.DocumentIsOpen(aDocument);
	iState=EStateIdle;
	TBool b=ETrue;
	if(r!=KErrNone)
		b=EFalse;
	iObserver->OnCheckDocument(r, b);
	}

void CBackupClient::RetreiveOwnerInfoL()
	{
	if (iState!=EStateIdle)
		User::Leave(KErrNotReady);
	//
	iState=EStateOwnerInfo;
	TBuf<256> Buf;
	TInt r=iClient.OwnerInfoAsText(Buf);
	iState=EStateIdle;
	iObserver->OnRetreiveOwnerInfo(r, Buf);
	}

void CBackupClient::RunL()
	{
	}

void CBackupClient::DoCancel()
	{
	}

//
//
//


RPlpBackSvrClient::RPlpBackSvrClient()
	{
	}

TInt RPlpBackSvrClient::DocumentListOpen(TUint32 &aHandle)
	{
	TAny* Params[KMaxMessageArguments] ={0};
	//
	aHandle=0;
	TPckgBuf<TUint32> h;
	Params[0]=&h;
	TInt r=SendReceive(EBakOpCodeAppListOpen, Params);
	if (r==KErrNone)
		aHandle=h();
	return r;
	}

TInt RPlpBackSvrClient::DocumentListRead(const TUint32 aHandle, TDes &anApp, TDes &aDoc, TInt& aId)
	{
	TAny* Params[KMaxMessageArguments];
	//
	TPckg<TInt> pckg(aId);

	Params[0]=(TAny*)aHandle;
	Params[1]=&anApp;
	Params[2]=&aDoc;
	Params[3]=&pckg;
	return SendReceive(EBakOpCodeAppListRead, Params);
	}

TInt RPlpBackSvrClient::DocumentListClose(const TUint32 aHandle)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)aHandle;
	return SendReceive(EBakOpCodeAppListClose, Params);
	}

TInt RPlpBackSvrClient::DocumentStop(const TDesC &aDocPath)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aDocPath;
	return SendReceive(EBakOpCodeDocStop, Params);
	}

TInt RPlpBackSvrClient::DocumentIsOpen(const TDesC &aDocPath)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aDocPath;
	return SendReceive(EBakOpCodeDocIsOpen, Params);
	}

TInt RPlpBackSvrClient::DocumentStart(const TDesC &aDocPath)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aDocPath;
	return SendReceive(EBakOpCodeStartDocument, Params);
	}

TInt RPlpBackSvrClient::AppStop(const TDesC &aApp, TInt aId)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aApp;
	Params[1]=(TAny*)aId;
	return SendReceive(EBakOpCodeAppStop, Params);
	}

TInt RPlpBackSvrClient::AppIsRunning(const TDesC &aApp, TInt aId)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aApp;
	Params[1]=(TAny*)aId;
	return SendReceive(EBakOpCodeAppIsRunning, Params);
	}

TInt RPlpBackSvrClient::DetailsFromApp(const TDesC &aCaption, TInt aId, TDes& aDll, TDes& aDocument)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aCaption;
	Params[1]=(TAny*)aId;
	Params[2]=&aDll;
	Params[3]=&aDocument;
	return SendReceive(EBakOpCodeDetailsFromApp, Params);
	}

TInt RPlpBackSvrClient::AppStart(const TDesC &aCommandLine)
	{
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=(TAny*)&aCommandLine;
	return SendReceive(EBakOpCodeStartApplication, Params);
	}

TInt RPlpBackSvrClient::OwnerInfoAsText(TDes &aBuf)
	{
	aBuf.SetLength(0);
	//
	TAny* Params[KMaxMessageArguments];
	//
	Params[0]=&aBuf;
	return SendReceive(EBakOpCodeOwnerInfo, Params);
	}