// Class implementation of the drive publishing classes -

// RDriveStateChangedPublisher,

//

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "drivepublisherTraces.h"

#endif

//

static const TUint8 table[][5] =

    {EUsbMsDriveState_Disconnected,

     EUsbMsDriveState_Disconnected,

     EUsbMsDriveState_Disconnected,

     EUsbMsDriveState_Disconnected,

     EUsbMsDriveState_Disconnected},

    {EUsbMsDriveState_Connecting,

     EUsbMsDriveState_Connecting,

     EUsbMsDriveState_Connecting,

     EUsbMsDriveState_Connecting,

     EUsbMsDriveState_Connecting},

    //EIdle,EActive,ELocked,EMediaNotPresent,EErrDisMounted

    {EUsbMsDriveState_Connected,

     EUsbMsDriveState_Active,

     EUsbMsDriveState_Locked,

     EUsbMsDriveState_MediaNotPresent,

     EUsbMsDriveState_Removed},

    {EUsbMsDriveState_Disconnecting,

     EUsbMsDriveState_Disconnecting,

     EUsbMsDriveState_Disconnecting,

     EUsbMsDriveState_Disconnecting,

     EUsbMsDriveState_Disconnecting}

    {

    _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

    _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

    TInt result = RProperty::Define(EUsbMsDriveState_MediaError, RProperty::EInt,

                                    KMassStorageReadPolicy, KMassStorageWritePolicy);

    __ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant());

    result = iMediaErrorProperty.Attach(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError);

    __ASSERT_DEBUG(result == KErrNone, User::Invariant());

    }

    {

    iMediaErrorProperty.Close();

    RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError);

    }

    {

    OstTraceFunctionEntry0(DRIVEPUBLISHER_100);

    TInt oldValue;

    iMediaErrorProperty.Get(oldValue);

    if (oldValue != aError)

        {

        User::LeaveIfError(iMediaErrorProperty.Set(aError));

        }

    }

                                                         TRefDriveMap aDriveMap)

    :

    iDrives(aDrives),

    iDriveMap(aDriveMap)

    {

    _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

    _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

    TInt result = RProperty::Define(KUsbMsDriveState_Category,

                                    EUsbMsDriveState_DriveStatus, RProperty::EByteArray,

                                    KMassStorageReadPolicy, KMassStorageWritePolicy,

                                    KUsbMsMaxDrives*2);

    __ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant());

    result = result;    // remove urel warning

    }

    {

    RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_DriveStatus);

    }

Sends a property event on behalf of CMassStorageDrive, with the mountstate and drivestate

    {

    TUsbMsDrivesStatus allDrivesStatus;

    for(TUint8 i=0; i<KUsbMsMaxDrives && iDrives[i]; i++)

        {

        allDrivesStatus.Append(iDriveMap[i]);

        CMassStorageDrive::TMountState ms = iDrives[i]->MountState();

        CMassStorageDrive::TDriveState ds = iDrives[i]->DriveState();

        TInt driveStatus = EUsbMsDriveState_Error;

        if((TUint8)ds < sizeof(table[0]) && (TUint8)ms < sizeof(table)/sizeof(table[0]))

            {

            driveStatus = table[ms][ds];

            OstTraceExt3(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_110,

                         "ms=%d ds=%d %d", ms, ds, driveStatus);

            }

        allDrivesStatus.Append(driveStatus);

        }

    OstTrace1(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_111,

              "Publishing EUsbMsDriveState_DriveStatus for %d drives", allDrivesStatus.Length()/2);

    if(KErrNone != RProperty::Set(KUsbMsDriveState_Category,

                                  EUsbMsDriveState_DriveStatus,

                                  allDrivesStatus))

        {

        __ASSERT_DEBUG(EFalse,User::Invariant());

        }

    }

@param aSubKey

    TUsbMsDriveState_Subkey aSubKey,

    TRefMsDriveList aDrives)

    :

    iSubKey(aSubKey),

    iDrives(aDrives)

    {

    }

    {

    _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

    _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

    TInt r = RProperty::Define(iSubKey, RProperty::EByteArray,

                               KMassStorageReadPolicy, KMassStorageWritePolicy,

                               KUsbMsMaxDrives*sizeof(TInt));

    if (r != KErrAlreadyExists)

        {

        User::LeaveIfError(r);

        }

    User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, iSubKey));

    // Create the EDataTransferred timer

    iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iTimerRunning = EFalse;

    }

    {

    if(iTimer)

        {

        iTimer->Cancel();

        }

    delete iTimer;

    iProperty.Close();

    RProperty::Delete(KUsbMsDriveState_Category, iSubKey);

    }

    {

    static_cast<CDriveTransferPublisher*>(obj)->DoPublishDataTransferredEvent();

    return 1;

    }

    {

    if (PublishDataTransferred())

        {

        // some data has been transfered so reset the counter

        iTimerCancelCnt = ETimerCancelDelay;

        }

    // Update the cancel count if no data was transferred the last

    // (few) times this has been called

    if (--iTimerCancelCnt == 0)

        {

        StopTimer();

        iTimerCancelCnt = ETimerCancelDelay;

        }

    }

Update the data transferred properties if the counts have changed since

    {

    TUsbMsBytesTransferred bytesTransferred;

    TBool dataTransferred = EFalse;

    for (TInt i=0; i < iDrives.Count() && iDrives[i]; i++)

        {

        bytesTransferred[i] = GetBytesTransferred(i);

        }

    // Update the properties only if they have changed

    // (or if there's an error reading the old value.)

    // Possible optimisation: keep a copy of the value

    // as a member variable so we don't need the Get.

    TUsbMsBytesTransferred oldValue;

    if ((iProperty.Get(oldValue) != KErrNone) || (oldValue != bytesTransferred))

        {

        for (TInt j=0; j < iDrives.Count() && iDrives[j]; j++)

            {

            if(oldValue[j] != bytesTransferred[j])

                {

                __PRINT3(_L("CDrivePublisher: KBytes[%d] %d->%d\n"), j, oldValue[j], bytesTransferred[j]);

                }

            }

        if (KErrNone != iProperty.Set(bytesTransferred))

            {

            __ASSERT_DEBUG(EFalse, User::Invariant());

            }

        dataTransferred = ETrue;

        }

    return dataTransferred;

    }

    {

    if (!iTimerRunning)

        {

        // EDataTransferred event every second

        const TTimeIntervalMicroSeconds32 interval = 1 * 1000 * 1000;

        TCallBack callback(PublishDataTransferredEvent, this);

        OstTrace0(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_140, "Starting timer");

        iTimer->Start(interval, interval, callback);

        iTimerRunning = ETrue;

        }

    }

    {

    if (iTimerRunning)

        {

        OstTrace0(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_141, "Stopping timer");

        iTimer->Cancel();

        iTimerRunning = EFalse;

        }

    }

    {

    CDriveWriteTransferPublisher* self = new (ELeave) CDriveWriteTransferPublisher(aDrives);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

    :

    CDriveTransferPublisher(EUsbMsDriveState_KBytesWritten, aDrives)

    {

    }

    {

    return iDrives[aLun]->KBytesWritten();

    }

    {

    CDriveReadTransferPublisher* self = new (ELeave) CDriveReadTransferPublisher(aDrives);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

    :

    CDriveTransferPublisher(EUsbMsDriveState_KBytesRead, aDrives)

    {

    }

    {

    return iDrives[aLun]->KBytesRead();

    }

    TUsbMsDriveState_Subkey aSubKey,

    TRefBytesTransferedList aArray)

    :

    iSubKey(aSubKey),

    iArray(aArray)

    {

    }

    {

    _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy);

    _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid);

    TInt r = RProperty::Define(iSubKey, RProperty::EByteArray,

                               KMassStorageReadPolicy, KMassStorageWritePolicy,

                               KUsbMsMaxDrives*sizeof(TInt));

    if (r != KErrAlreadyExists)

        {

        User::LeaveIfError(r);

        }

    // Attach to the properties here. Only do this once, continuously attaching

    // will currently cause a memory leak

    User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, iSubKey));

    // Create the EDataTransferred timer

    iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iTimerRunning = EFalse;

    }

    {

    if(iTimer)

        {

        iTimer->Cancel();

        }

    delete iTimer;

    iProperty.Close();

    RProperty::Delete(KUsbMsDriveState_Category, iSubKey);

    }

    {

    static_cast<CUsbTransferPublisher*>(obj)->DoPublishDataTransferredEvent();

    return 1;