/*

* Copyright (c) 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:  Definitions for the class TATDriveInfo.

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <driveinfo.h>

#include "atdriveinfo.h"

#include "atlog.h"

// -----------------------------------------------------------------------------

// TATDriveInfo::TATDriveInfo

// C++ default constructor.

// -----------------------------------------------------------------------------

//

TATDriveInfo::TATDriveInfo()

    {

    LOGSTR1( "TATD TATDriveInfo::TATDriveInfo()" );

    }

// -----------------------------------------------------------------------------

// TATDriveInfo::CreatePath()

// -----------------------------------------------------------------------------

//    

TInt TATDriveInfo::CreatePath( TDes& aPath, 

    const TDesC& aFileName, const TDesC& aFilePath, RFs& aFs )

    {

    LOGSTR1( "TATD TInt TATDriveInfo::CreatePath()" );

    TInt err( KErrNotFound );

    // first try to create user defined directory

    if( aFilePath.Length()>0 )

    	{

		err = aFs.MkDir( aFilePath );

		LOGSTR2( "STSE > defined path aFs.MkDir err = %i", err );

		if ( !err || err == KErrAlreadyExists )

			{

			//directory was succesfully created or exists

			aPath.Copy( aFilePath );

			if ( aFileName.Length() != 0 && 

				 ( ( aPath.MaxLength() - aPath.Length() ) > aFileName.Length() ) )

				{

				aPath.Append( aFileName );

				}

			return err;

			}

		else if( err == KErrBadName )

			{

			// TODO bad path, log error

			// log default name in the end of function

			}

    	}

	//error when trying to create user defined directory, lets use default paths

    // Drive letter    

    TChar driveLetter;

    // Drive number

    TInt dNumber( EDriveZ );     

    TBool found( EFalse );

    // Drive type

    TUint driveType( KDriveAttRemovable );    

    while ( !found )

        {

        // Get drive letter

        if ( GetDrive( driveLetter, dNumber, aFs, driveType ) == KErrNotFound )

        	{

        	if ( driveType == KDriveAttInternal )

        		{

                return KErrNotFound;

        		}       	

            driveType = KDriveAttInternal;

        	dNumber = EDriveZ;

        	}       

        else

        	{

			// Create path

			aPath.Delete( 0, aPath.MaxLength() );

			aPath.Append( driveLetter );

		#ifdef __WINS__

            // For emulator the data file is stored to different location

            aPath.Append( KATDataFilePath );       

		#else

		    TDriveInfo driveInfo;

		    aFs.Drive( driveInfo, dNumber );      

            // The drive is removable( memory card ) so we can log inside of root folder

            if ( driveInfo.iDriveAtt & KDriveAttRemovable )

                {

                aPath.Append( KATDataFilePath );       

                }

            // The drive is internal user can only access data folder so log into that

            else

                {

                aPath.Append( KATDataFilePath2 );       

                }

		#endif

			// Make a directory for logging data file

			err = aFs.MkDir( aPath );

			LOGSTR2( "STSE > aFs.MkDir err = %i", err );

			if ( !err || err == KErrAlreadyExists )

				{                

                if ( aFileName.Length() != 0 && 

                     ( ( aPath.MaxLength() - aPath.Length() ) > aFileName.Length() ) )

                    {

                    aPath.Append( aFileName );

                    }

				found = ETrue;

				}

        	}

        }        

    return err;        

    }

// -----------------------------------------------------------------------------

// TATDriveInfo::GetDrive()

// -----------------------------------------------------------------------------

//    

TInt TATDriveInfo::GetDrive( TChar& aDrive, TInt& aDriveNumber, RFs& aFs, 

	const TUint aDriveType )

    {

    LOGSTR1( "TATD TInt TATDriveInfo::GetDrive()" );

    // Contains drive information.

    TDriveInfo driveInfo; 

    for ( TInt i = aDriveNumber; i >= (TInt)EDriveA; i-- )

        {

        // Gets information about a drive and the medium mounted on it.

        // If error occured then skip to next drive.

        if ( aFs.Drive( driveInfo, i ) != KErrNone )

            continue;

        // Test whether drive is available. If not, skip to next drive.

        if ( driveInfo.iDriveAtt & KDriveAbsent || i == (TInt)EDriveD ||

             driveInfo.iDriveAtt & KDriveAttRom || 

             driveInfo.iMediaAtt & KMediaAttWriteProtected ||

             driveInfo.iDriveAtt & KDriveFileSysROFS )

            continue;

        // Maps a drive number to the corresponding character.

        if ( aFs.DriveToChar( i, aDrive ) != KErrNone )

            continue;                

        if ( driveInfo.iDriveAtt & aDriveType &&

             driveInfo.iType != EMediaNotPresent &&

             driveInfo.iType != EMediaCdRom )

            {

            TUint status( 0 );

            switch ( aDriveType )

                {

                case KDriveAttRemovable:

                    {

                    // Get the drive status of the default removable mass storage.                    

                    if ( DriveInfo::GetDriveStatus( aFs, i, status ) == KErrNone )

                        {

                        // To indicate that the drive is physically removable.

                        if ( status & DriveInfo::EDriveRemovable &&

                             !( status & DriveInfo::EDriveCorrupt ) )

                            {

                            aDriveNumber = --i;

                            return KErrNone;

                            }

                        }

                    }

                    break;

                case KDriveAttInternal:

                    {

                    // Get the drive status of the default removable mass storage.

                    if ( DriveInfo::GetDriveStatus( aFs, i, status ) == KErrNone )

                        {

                        // To indicate that the drive is internal and 

                        // cannot be physically removed.

                        if ( status & DriveInfo::EDriveInternal &&

                             !( status & DriveInfo::EDriveExternallyMountable ) )

                            {

                            aDriveNumber = --i;

                            return KErrNone;

                            }

                        }

                    }

                    break;

                default:

                    break;

                }

            }

        }

    return KErrNotFound;

    }

// End of File