557 { |
594 { |
558 session->CompleteTaskRequests(aStatus); |
595 session->CompleteTaskRequests(aStatus); |
559 session = (CEventMediatorSession*) iSessionIter++; |
596 session = (CEventMediatorSession*) iSessionIter++; |
560 } |
597 } |
561 } |
598 } |
562 |
|
563 void CEventMediatorServer::SetShuttingDown(TBool aShuttingDown) |
|
564 { |
|
565 iShuttingDown = aShuttingDown; |
|
566 } |
|
567 |
|
568 // ============================= CEventMediatorSession ============================= |
|
569 |
|
570 CEventMediatorSession* CEventMediatorSession::NewL(CEventMediatorServer* aServer, const RMessage2& aMessage) |
|
571 { |
|
572 LOG(Log::Printf(_L("CEventMediatorSession::NewL - begin\n"))); |
|
573 CEventMediatorSession* self; |
|
574 self = new (ELeave) CEventMediatorSession(aServer); |
|
575 CleanupStack::PushL(self); |
|
576 |
|
577 // Marks the session as a "SIT session" |
|
578 // if the client is the SIT thread |
|
579 self->iIsSitSession = aServer->IsClientTheSitL(aMessage); |
|
580 |
|
581 aServer->iSessionCount++; |
|
582 |
|
583 if ( !self->IsASitSession() ) |
|
584 { |
|
585 User::LeaveIfError(self->iFs.Connect()); // For EventLog |
|
586 self->iEventLogFileOpen = EFalse; |
|
587 } |
|
588 |
|
589 CleanupStack::Pop(); // self |
|
590 |
|
591 LOG(Log::Printf(_L("CEventMediatorSession::NewL - end\n"))); |
|
592 return self; |
|
593 } |
|
594 |
|
595 CEventMediatorSession::CEventMediatorSession(CEventMediatorServer* aServer) |
|
596 : iListenedEvents(2), iServer(aServer) |
|
597 { |
|
598 } |
|
599 |
|
600 CEventMediatorSession::~CEventMediatorSession(void) |
|
601 { |
|
602 LOG(Log::Printf(_L("CEventMediatorSession::~CEventMediatorSession\n"))); |
|
603 CancelAll(); |
|
604 if (iServer) |
|
605 { |
|
606 TInt normalSessionCount = iServer->NormalSessionCount(); |
|
607 |
|
608 // If this too is a normal session and is dying, |
|
609 // decrement the normal session count by one |
|
610 if (!IsASitSession()) |
|
611 { |
|
612 normalSessionCount--; |
|
613 |
|
614 if (iEventLogFileOpen) |
|
615 { |
|
616 iEventLogFile.Close(); |
|
617 iEventLogFileOpen = EFalse; |
|
618 } |
|
619 iFs.Close(); // For EventLog |
|
620 |
|
621 } |
|
622 |
|
623 if (normalSessionCount == 0) |
|
624 { |
|
625 // If "normal" (non-sit) sessions are no longer present, |
|
626 // we complete the task arrival observation request, thus |
|
627 // causing the SIT to terminate and close its connection |
|
628 // to this server. This should be the last connection whose |
|
629 // closing will cause this server to terminate. |
|
630 // NOTE. KErrCancel cannot be used here as the Event Mediator |
|
631 // does not report it to the caller |
|
632 LOG(Log::Printf(_L("CEventMediatorSession::~CEventMediatorSession - normal session count = 0\n"))); |
|
633 iServer->CompleteListener(ETaskArrivedEvent, NULL, KErrAbort); |
|
634 |
|
635 // Set the server state to "shutting down". This will |
|
636 // cause the server to discard any new connect requests |
|
637 // with KErrServerTerminated. |
|
638 iServer->SetShuttingDown(ETrue); |
|
639 } |
|
640 |
|
641 if (iServer->iSessionCount) |
|
642 { |
|
643 iServer->iSessionCount--; |
|
644 } |
|
645 |
|
646 iServer->StopEventMediator(); |
|
647 } |
|
648 } |
|
649 |
|
650 void CEventMediatorSession::ServiceL(const RMessage2& aMessage) |
|
651 { |
|
652 TInt status = 0; |
|
653 |
|
654 switch (aMessage.Function()) |
|
655 { |
|
656 case KEventMediatorListen: |
|
657 ListenToEventL(aMessage); |
|
658 break; |
|
659 |
|
660 case KEventMediatorListenWithSpec: |
|
661 ListenToEventWithSpecL(aMessage); |
|
662 break; |
|
663 |
|
664 case KEventMediatorCancel: |
|
665 CancelListening(aMessage); |
|
666 aMessage.Complete(KErrNone); |
|
667 break; |
|
668 |
|
669 case KEventMediatorCancelWithSpec: |
|
670 CancelListeningWithSpecL(aMessage); |
|
671 aMessage.Complete(KErrNone); |
|
672 break; |
|
673 |
|
674 case KEventMediatorCancelAll: |
|
675 CancelAll(); |
|
676 aMessage.Complete(KErrNone); |
|
677 break; |
|
678 |
|
679 case KEventMediatorReportEvent: |
|
680 ReportEventL(aMessage); |
|
681 aMessage.Complete(KErrNone); |
|
682 break; |
|
683 |
|
684 case KEventMediatorReportEventWithSpec: |
|
685 ReportEventWithSpecL(aMessage); |
|
686 aMessage.Complete(KErrNone); |
|
687 break; |
|
688 |
|
689 case KEventMediatorFetchData: |
|
690 status = FetchDataL(aMessage); |
|
691 aMessage.Complete(status); |
|
692 break; |
|
693 |
|
694 case KEventMediatorReportLogEvent: |
|
695 ReportLogEventL(aMessage); |
|
696 aMessage.Complete(KErrNone); |
|
697 break; |
|
698 |
|
699 case KEventMediatorNewEventSpecId: |
|
700 NewEventSpecIdL(aMessage); |
|
701 aMessage.Complete(KErrNone); |
|
702 break; |
|
703 case KEventMediatorDeletePrivateFiles: |
|
704 status = DeletePrivateFiles(); |
|
705 aMessage.Complete(status); |
|
706 break; |
|
707 |
|
708 case KEventMediatorGetEventLogSize: |
|
709 status = GetEventLogSize(aMessage); |
|
710 aMessage.Complete(status); |
|
711 break; |
|
712 |
|
713 case KEventMediatorGetEventLogHeader: |
|
714 status = GetEventLogHeader(aMessage); |
|
715 aMessage.Complete(status); |
|
716 break; |
|
717 case KEventMediatorGetEventLogData: |
|
718 status = GetEventLogData(aMessage); |
|
719 aMessage.Complete(status); |
|
720 break; |
|
721 case KEventMediatorClearEventLog: |
|
722 status = ClearEventLog(); |
|
723 aMessage.Complete(status); |
|
724 break; |
|
725 default: |
|
726 aMessage.Complete(KErrGeneral); |
|
727 break; |
|
728 } |
|
729 } |
|
730 |
|
731 TInt CEventMediatorSession::ListenToEventL(const RMessage2& aMessage) |
|
732 { |
|
733 CListenerContainer* listener = new (ELeave) CListenerContainer(aMessage, NULL, iServer); |
|
734 CleanupStack::PushL(listener); |
|
735 |
|
736 iListenedEvents.AppendL(listener); |
|
737 CleanupStack::Pop(); // listener |
|
738 |
|
739 listener->AnalyzeRequestL(); |
|
740 |
|
741 return KErrNone; |
|
742 } |
|
743 |
|
744 TInt CEventMediatorSession::ListenToEventWithSpecL(const RMessage2& aMessage) |
|
745 { |
|
746 HBufC8* specBuf = NULL; |
|
747 |
|
748 // Read specification |
|
749 specBuf = ReadSpecificationFromClientL(aMessage); |
|
750 CleanupStack::PushL(specBuf); |
|
751 |
|
752 // Ownership of specBuf is given to listener |
|
753 CListenerContainer* listener = new (ELeave) CListenerContainer(aMessage, specBuf, iServer); |
|
754 CleanupStack::Pop(); // specBuf |
|
755 CleanupStack::PushL(listener); |
|
756 |
|
757 iListenedEvents.AppendL(listener); |
|
758 CleanupStack::Pop(); // listener |
|
759 |
|
760 listener->AnalyzeRequestL(); |
|
761 |
|
762 return KErrNone; |
|
763 } |
|
764 |
|
765 void CEventMediatorSession::CancelListening(const RMessage2& aMessage) |
|
766 { |
|
767 TInt index; |
|
768 |
|
769 while (FindListenerMsg((TEventType)aMessage.Int0(), index)) |
|
770 { |
|
771 CompleteListener(index, KErrCancel); |
|
772 } |
|
773 } |
|
774 |
|
775 void CEventMediatorSession::CancelListeningWithSpecL(const RMessage2& aMessage) |
|
776 { |
|
777 HBufC8* specBuf = NULL; |
|
778 TInt index; |
|
779 |
|
780 // Read specification |
|
781 specBuf = ReadSpecificationFromClientL(aMessage); |
|
782 CleanupStack::PushL(specBuf); |
|
783 |
|
784 // Cancel listeners |
|
785 while (FindListenerMsg((TEventType)aMessage.Int0(), specBuf, index)) |
|
786 { |
|
787 CompleteListener(index, KErrCancel); |
|
788 } |
|
789 CleanupStack::PopAndDestroy(); // specBuf |
|
790 } |
|
791 |
|
792 void CEventMediatorSession::CancelAll() |
|
793 { |
|
794 TInt nEvents = iListenedEvents.Count(); |
|
795 for (TInt i = 0; i < nEvents; i++) |
|
796 { |
|
797 iListenedEvents.At(i)->Complete(KErrCancel); |
|
798 delete iListenedEvents.At(i); |
|
799 iListenedEvents.At(i) = NULL; |
|
800 } |
|
801 iListenedEvents.Reset(); |
|
802 } |
|
803 |
|
804 void CEventMediatorSession::ReportEventL(const RMessage2& aMessage) |
|
805 { |
|
806 TEventType eventType = (TEventType)aMessage.Int0(); |
|
807 LOG(Log::Printf(_L("CEventMediatorSession::ReportEventL - event type = %d\n"), eventType)); |
|
808 // Read data |
|
809 HBufC8* dataBuf = ReadEventDataFromClientL(aMessage); |
|
810 CleanupStack::PushL(dataBuf); |
|
811 // Report event to server |
|
812 iServer->ReportEventL(eventType, NULL, dataBuf); |
|
813 CleanupStack::Pop(); |
|
814 } |
|
815 |
|
816 void CEventMediatorSession::ReportEventWithSpecL(const RMessage2& aMessage) |
|
817 { |
|
818 TEventType eventType=(TEventType) aMessage.Int0(); |
|
819 LOG(Log::Printf(_L("CEventMediatorSession::ReportEventWithSpecL - event type = %d\n"), eventType)); |
|
820 // Read data |
|
821 HBufC8* dataBuf = ReadEventDataFromClientL(aMessage); |
|
822 CleanupStack::PushL(dataBuf); |
|
823 // Read specification |
|
824 HBufC8* specBuf = ReadSpecificationFromClientL(aMessage); |
|
825 CleanupStack::PushL(specBuf); |
|
826 // Report event to server |
|
827 iServer->ReportEventL(eventType, specBuf, dataBuf); |
|
828 CleanupStack::PopAndDestroy(); // specBuf |
|
829 CleanupStack::Pop(); // dataBuf |
|
830 } |
|
831 |
|
832 void CEventMediatorSession::ReportLogEventL(const RMessage2& aMessage) |
|
833 { |
|
834 LOG(Log::Printf(_L("CEventMediatorSession::ReportLogEventL\n"))); |
|
835 // Read event |
|
836 TLogEvent event; |
|
837 TPckg<TLogEvent> eventPckg(event); |
|
838 aMessage.ReadL(FIRST_ARGUMENT, eventPckg); |
|
839 |
|
840 // Create one buffer to contain put everything in a normal buffer and |
|
841 TInt lengthsDesLth = event.iDesCount * sizeof(TInt); |
|
842 TInt position = eventPckg.Length(); |
|
843 TInt dataLength = position + lengthsDesLth + aMessage.Int2(); |
|
844 HBufC8* dataBuf = HBufC8::NewLC(dataLength); |
|
845 TPtr8 dataPtr = dataBuf->Des(); |
|
846 |
|
847 // Copy event to buffer |
|
848 dataPtr.Append(eventPckg); |
|
849 // Read lengths to buffer |
|
850 TPtr8 tmpPtr(&dataPtr[position], 0, dataLength - position); |
|
851 aMessage.ReadL(SECOND_ARGUMENT, tmpPtr); |
|
852 // Read descriptors to the buffer |
|
853 position= dataPtr.Length(); |
|
854 tmpPtr.Set(&dataPtr[position], 0, dataLength - position); |
|
855 aMessage.ReadL(THIRD_ARGUMENT, tmpPtr); |
|
856 |
|
857 // Report event to server |
|
858 iServer->ReportEventL(ELogEvent, NULL, dataBuf); |
|
859 CleanupStack::Pop(); |
|
860 } |
|
861 |
|
862 TInt CEventMediatorSession::FetchDataL(const RMessage2& aMessage) |
|
863 { |
|
864 LOG(Log::Printf(_L("CEventMediatorSession::FetchDataL\n"))); |
|
865 return iServer->CopyEventDataL(aMessage); |
|
866 } |
|
867 |
|
868 TInt CEventMediatorSession::CheckEventL(const TEventType aType, const TDesC8* aSpec, |
|
869 const TDesC8* aData, TInt aStatus) |
|
870 { |
|
871 TInt index; |
|
872 TInt listenerCount = 0; |
|
873 TInt dataLth = 0; |
|
874 // Some events don't not have data |
|
875 if (aData) |
|
876 { |
|
877 dataLth = aData->Length(); |
|
878 } |
|
879 TPckg<TInt> lengthpckg(dataLth); |
|
880 TPckgC<const TAny*> ptrpckg(aData); |
|
881 |
|
882 while (FindListenerMsg(aType, aSpec, index)) |
|
883 { |
|
884 RMessage2& listener = iListenedEvents.At(index)->Message(); |
|
885 |
|
886 if (aStatus == KErrNone) |
|
887 { |
|
888 // Write info about data |
|
889 listener.WriteL(SECOND_ARGUMENT, lengthpckg); |
|
890 listener.WriteL(THIRD_ARGUMENT, ptrpckg); |
|
891 |
|
892 // Complete listener |
|
893 listener.Complete(KErrNone); |
|
894 } |
|
895 else |
|
896 { |
|
897 listener.Complete(aStatus); |
|
898 } |
|
899 |
|
900 delete iListenedEvents.At(index); |
|
901 iListenedEvents.Delete(index); |
|
902 listenerCount++; |
|
903 } |
|
904 |
|
905 return listenerCount; |
|
906 } |
|
907 |
|
908 TBool CEventMediatorSession::FindListenerMsg(const TEventType aType, TInt& index) |
|
909 { |
|
910 for (TInt i = 0; i < iListenedEvents.Count(); i++) |
|
911 { |
|
912 if (iListenedEvents.At(i)->Type() == aType) |
|
913 { |
|
914 index=i; |
|
915 return ETrue; |
|
916 } |
|
917 } |
|
918 return EFalse; |
|
919 } |
|
920 |
|
921 TBool CEventMediatorSession::FindListenerMsg(const TEventType aType, const TDesC8* aSpec, TInt& index) |
|
922 { |
|
923 for (TInt i = 0; i < iListenedEvents.Count(); i++) |
|
924 { |
|
925 if (iListenedEvents.At(i)->HandlesEvent(aType, aSpec)) |
|
926 { |
|
927 index = i; |
|
928 return ETrue; |
|
929 } |
|
930 } |
|
931 return EFalse; |
|
932 } |
|
933 |
|
934 TBool CEventMediatorSession::FindTaskRequestListenerMsg(TInt& index) |
|
935 { |
|
936 for (TInt i = 0; i < iListenedEvents.Count(); i++) |
|
937 { |
|
938 if (CSit::EventRequiresSit(iListenedEvents.At(i)->Type())) |
|
939 { |
|
940 index = i; |
|
941 return ETrue; |
|
942 } |
|
943 } |
|
944 return EFalse; |
|
945 } |
|
946 |
|
947 HBufC8* CEventMediatorSession::ReadSpecificationFromClientL(const RMessage2& aMessage) |
|
948 { |
|
949 HBufC8* specBuf; |
|
950 // Read specification descriptor length from client, create specification buffer |
|
951 const TAny* desPtr = aMessage.Ptr3(); |
|
952 if (desPtr == NULL) |
|
953 { |
|
954 return NULL; |
|
955 } |
|
956 TInt specLength = aMessage.GetDesLength(FOURTH_ARGUMENT); |
|
957 // Create spcification buffer |
|
958 specBuf = HBufC8::NewLC(specLength); |
|
959 TPtr8 ptr = specBuf->Des(); |
|
960 // Read specification |
|
961 aMessage.ReadL(FOURTH_ARGUMENT, ptr); |
|
962 CleanupStack::Pop(); // specBuf |
|
963 return specBuf; |
|
964 } |
|
965 |
|
966 HBufC8* CEventMediatorSession::ReadEventDataFromClientL(const RMessage2& aMessage) |
|
967 { |
|
968 HBufC8* dataBuf = NULL; |
|
969 TInt desLength = aMessage.Int1(); |
|
970 |
|
971 if (desLength != 0) // Some events have no data |
|
972 { |
|
973 dataBuf = HBufC8::NewLC(desLength); |
|
974 TPtr8 ptr = dataBuf->Des(); |
|
975 aMessage.ReadL(THIRD_ARGUMENT, ptr); |
|
976 CleanupStack::Pop(); // dataBuf |
|
977 } |
|
978 return dataBuf; |
|
979 } |
|
980 |
|
981 CListenerContainer* CEventMediatorSession::FindWaitingTaskRequest() |
|
982 { |
|
983 CListenerContainer* listener = NULL; |
|
984 |
|
985 for (TInt i = 0; i < iListenedEvents.Count(); i++) |
|
986 { |
|
987 if (iListenedEvents.At(i)->WaitingForFulfilling()) |
|
988 { |
|
989 listener = iListenedEvents.At(i); |
|
990 break; |
|
991 } |
|
992 } |
|
993 |
|
994 return listener; |
|
995 } |
|
996 |
|
997 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType, |
|
998 TInt aEventSpecId) |
|
999 { |
|
1000 CListenerContainer* listener = NULL; |
|
1001 |
|
1002 for (TInt i = 0; i < iListenedEvents.Count(); i++) |
|
1003 { |
|
1004 if (iListenedEvents.At(i)->Type() == aEventType) |
|
1005 { |
|
1006 TEventSpec* eventSpec = (TEventSpec*)(iListenedEvents.At(i)->Specification()->Ptr()); |
|
1007 |
|
1008 if (eventSpec->iId == aEventSpecId) |
|
1009 { |
|
1010 listener = iListenedEvents.At(i); |
|
1011 break; |
|
1012 } |
|
1013 } |
|
1014 } |
|
1015 |
|
1016 return listener; |
|
1017 } |
|
1018 |
|
1019 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType, |
|
1020 const TDesC8* aEventSpec) |
|
1021 { |
|
1022 CListenerContainer* listener = NULL; |
|
1023 |
|
1024 for (TInt i = 0; i < iListenedEvents.Count(); i++) |
|
1025 { |
|
1026 if (iListenedEvents.At(i)->HandlesEvent(aEventType, aEventSpec)) |
|
1027 { |
|
1028 listener = iListenedEvents.At(i); |
|
1029 break; |
|
1030 } |
|
1031 } |
|
1032 |
|
1033 return listener; |
|
1034 } |
|
1035 |
|
1036 void CEventMediatorSession::CompleteListener(TEventType aEventType, |
|
1037 const TDesC8* aEventSpec, |
|
1038 TInt aStatus) |
|
1039 { |
|
1040 TInt index; |
|
1041 while (FindListenerMsg(aEventType, aEventSpec, index)) |
|
1042 { |
|
1043 CompleteListener(index, aStatus); |
|
1044 } |
|
1045 } |
|
1046 |
|
1047 void CEventMediatorSession::CompleteListener(TInt aIndex, TInt aStatus) |
|
1048 { |
|
1049 iListenedEvents.At(aIndex)->Complete(aStatus); |
|
1050 delete iListenedEvents.At(aIndex); |
|
1051 iListenedEvents.Delete(aIndex); |
|
1052 } |
|
1053 |
|
1054 void CEventMediatorSession::CompleteTaskRequests(TInt aStatus) |
|
1055 { |
|
1056 LOG(Log::Printf(_L("CEventMediatorSession::CompleteTaskRequests\n"))); |
|
1057 TInt index; |
|
1058 while (FindTaskRequestListenerMsg(index)) |
|
1059 { |
|
1060 CompleteListener(index, aStatus); |
|
1061 } |
|
1062 } |
|
1063 |
|
1064 TBool CEventMediatorSession::IsASitSession() |
|
1065 { |
|
1066 return iIsSitSession; |
|
1067 } |
|
1068 |
|
1069 void CEventMediatorSession::NewEventSpecIdL(const RMessage2& aMessage) |
|
1070 { |
|
1071 TInt newEventSpecId = iServer->NewEventSpecId(); |
|
1072 TPckg<TInt> newEventSpecIdDes(newEventSpecId); |
|
1073 aMessage.WriteL(FIRST_ARGUMENT, newEventSpecIdDes); |
|
1074 } |
|
1075 |
|
1076 TInt CEventMediatorSession::DeletePrivateFiles() |
|
1077 { |
|
1078 TRAPD(err, DeletePrivateFilesL()); |
|
1079 if ( err ) |
|
1080 { |
|
1081 LOG(Log::Printf(_L("DeletePrivateFilesL() leave error %d\n"), err)); |
|
1082 return err; |
|
1083 } |
|
1084 |
|
1085 return KErrNone; |
|
1086 } |
|
1087 |
|
1088 void CEventMediatorSession::DeletePrivateFilesL() |
|
1089 { |
|
1090 LOG(Log::Printf(_L("DeletePrivateFilesL() called\n"))); |
|
1091 |
|
1092 CFileMan* fileMan = CFileMan::NewL(iFs); |
|
1093 CleanupStack::PushL(fileMan); |
|
1094 |
|
1095 TPath privateDir; |
|
1096 User::LeaveIfError(iFs.PrivatePath(privateDir)); |
|
1097 |
|
1098 TInt err = fileMan->RmDir(privateDir); |
|
1099 if (err != KErrNone && err != KErrPathNotFound && err != KErrNotFound) |
|
1100 { |
|
1101 User::Leave(err); |
|
1102 } |
|
1103 CleanupStack::PopAndDestroy(); //fileMan |
|
1104 } |
|
1105 |
|
1106 TInt CEventMediatorSession::GetEventLogSize( |
|
1107 const RMessage2& aMessage) |
|
1108 { |
|
1109 if ( iEventLogFileOpen ) |
|
1110 { |
|
1111 iEventLogFile.Close(); |
|
1112 iEventLogFileOpen = EFalse; |
|
1113 } |
|
1114 |
|
1115 TInt err = iEventLogFile.Open(iFs, iServer->EventLogFileName(), EFileRead | EFileShareAny); |
|
1116 if ( err ) |
|
1117 return err; |
|
1118 |
|
1119 TInt size(0); |
|
1120 err = iEventLogFile.Size(size); |
|
1121 if ( err ) |
|
1122 { |
|
1123 iEventLogFile.Close(); |
|
1124 return err; |
|
1125 } |
|
1126 |
|
1127 TPckg<TInt> sizePckg(size); |
|
1128 err = aMessage.Write(FIRST_ARGUMENT, sizePckg); |
|
1129 if ( err ) |
|
1130 { |
|
1131 iEventLogFile.Close(); |
|
1132 return err; |
|
1133 } |
|
1134 |
|
1135 iEventLogFileOpen = ETrue; |
|
1136 |
|
1137 return KErrNone; |
|
1138 } |
|
1139 |
|
1140 TInt CEventMediatorSession::GetEventLogHeader( |
|
1141 const RMessage2& aMessage) |
|
1142 { |
|
1143 TInt err(0); |
|
1144 |
|
1145 if ( !iEventLogFileOpen ) |
|
1146 { |
|
1147 err = iEventLogFile.Open(iFs, iServer->EventLogFileName(), EFileRead | EFileShareAny); |
|
1148 if ( err ) |
|
1149 return err; |
|
1150 iEventLogFileOpen = ETrue; |
|
1151 } |
|
1152 |
|
1153 TInt position = 0; |
|
1154 err = iEventLogFile.Seek(ESeekStart, position); |
|
1155 if (err != KErrNone) |
|
1156 return err; |
|
1157 |
|
1158 TBuf8<EVENTLOG_FILE_HEADER_LTH> fileHeaderBuf; |
|
1159 err = iEventLogFile.Read(fileHeaderBuf, EVENTLOG_FILE_HEADER_LTH); |
|
1160 if (err != KErrNone) |
|
1161 return err; |
|
1162 |
|
1163 TRAP(err, aMessage.WriteL(FIRST_ARGUMENT, fileHeaderBuf)); |
|
1164 if ( err ) |
|
1165 return err; |
|
1166 |
|
1167 return KErrNone; |
|
1168 } |
|
1169 |
|
1170 TInt CEventMediatorSession::GetEventLogData( |
|
1171 const RMessage2& aMessage) |
|
1172 { |
|
1173 TInt err(0); |
|
1174 |
|
1175 if ( !iEventLogFileOpen ) |
|
1176 { |
|
1177 err = iEventLogFile.Open(iFs, iServer->EventLogFileName(), EFileRead | EFileShareAny); |
|
1178 if ( err ) |
|
1179 return err; |
|
1180 iEventLogFileOpen = ETrue; |
|
1181 } |
|
1182 |
|
1183 TInt size(0); |
|
1184 err = iEventLogFile.Size(size); |
|
1185 if ( err ) |
|
1186 return err; |
|
1187 |
|
1188 if ( size < EVENTLOG_FILE_HEADER_LTH ) |
|
1189 return KErrNotFound; |
|
1190 |
|
1191 HBufC8* eventLogFileBuf = NULL; |
|
1192 TRAP(err, eventLogFileBuf = HBufC8::NewL(size)); |
|
1193 if ( err ) |
|
1194 { |
|
1195 return err; |
|
1196 } |
|
1197 |
|
1198 TPtr8 eventLogDataPtr(eventLogFileBuf->Des()); |
|
1199 TInt position(0); |
|
1200 err = iEventLogFile.Seek(ESeekStart, position); |
|
1201 if ( err ) |
|
1202 { |
|
1203 delete eventLogFileBuf; |
|
1204 return err; |
|
1205 } |
|
1206 err = iEventLogFile.Read(eventLogDataPtr); // iLogFileSize); |
|
1207 if ( err ) |
|
1208 { |
|
1209 delete eventLogFileBuf; |
|
1210 return err; |
|
1211 } |
|
1212 |
|
1213 TRAP( err, aMessage.WriteL(FIRST_ARGUMENT, eventLogDataPtr)); |
|
1214 if ( err ) |
|
1215 { |
|
1216 delete eventLogFileBuf; |
|
1217 return err; |
|
1218 } |
|
1219 |
|
1220 delete eventLogFileBuf; |
|
1221 eventLogFileBuf = NULL; |
|
1222 |
|
1223 return KErrNone; |
|
1224 } |
|
1225 |
|
1226 TInt CEventMediatorSession::ClearEventLog() |
|
1227 { |
|
1228 if ( iEventLogFileOpen ) |
|
1229 { |
|
1230 iEventLogFile.Close(); |
|
1231 iEventLogFileOpen = EFalse; |
|
1232 } |
|
1233 |
|
1234 TInt err = iFs.Delete(iServer->EventLogFileName()); |
|
1235 |
|
1236 return err; |
|
1237 } |
|
1238 |
|
1239 |
|
1240 |
599 |
1241 // ============================= CEventMediatorServer ============================= |
600 // ============================= CEventMediatorServer ============================= |
1242 |
601 |
1243 CListenerContainer::CListenerContainer(const RMessage2& aMessage, TDesC8* aSpec, |
602 CListenerContainer::CListenerContainer(const RMessage2& aMessage, TDesC8* aSpec, |
1244 CEventMediatorServer* aServer) |
603 CEventMediatorServer& aServer) |
1245 : iSpec(aSpec), iMessage(aMessage), iServer(aServer) |
604 : iSpec(aSpec), iMessage(aMessage), iServer(aServer) |
1246 { |
605 { |
1247 iEventType = Type(); |
606 iEventType = Type(); |
1248 } |
607 } |
1249 |
608 |