examples/PIPS/hybridapp/src/hybridapp.cpp

Go to the documentation of this file.

/*
Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
� list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
� this list of conditions and the following disclaimer in the documentation
� and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
� may be used to endorse or promote products derived from this software
� without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: Demonstrates an OE hybrid application.� 
*/




#include <stdio.h>
#include <f32file.h>
#include <stdlib.h>
#include <string.h>

char* DescToChar(const TDesC& aDes)
        {
        // Get the length of the descriptor.
        TInt length = aDes.Length();

        // Allocate memory to the array of characters.
        // An additional byte of memory is allocated to the array as 
        // Symbian descriptors do not end with the end of string '\0' character.
        char* ptr = (char*)malloc(sizeof(char)*(length + 1));
        if(ptr == NULL)
                {
                // Return NULL if memory was not allocated properly.
                return NULL;
                }
        // The loop index.
        TInt ix = 0;
        for(; ix < length; ix++)
                {
                // Copy the contents of the descriptor into the array of characters.
                ptr[ix] = aDes[ix];
                }
        // Append the end of string to the 'C' style string.
        ptr[ix] = '\0';

        // return the pointer to the array.
        return ptr;
        }

void PrintDriveInfoL(const RFs& aFs, const TInt aDriveNumber)
        {
        // Get the drive information
        TDriveInfo driveInfo;
        TInt errDrive = aFs.Drive(driveInfo,aDriveNumber);
        if(errDrive != KErrNone)
                return;

        // Get the name of the drive.
        TBuf<KMaxFileName> driveName;
        TInt errName = aFs.GetDriveName(aDriveNumber,driveName);
        if(errName != KErrNone)
                return;

        // Convert the drive name from native Symbian descriptor string to a 'C' string.
        char* cptr = DescToChar(driveName);
        CleanupStack::PushL(cptr);
        // Check if a name has been specified for the drive.
        if(strlen(cptr))
                {
                // Print the name of the drive.
                printf("Drive Name :%s\n",cptr);
                }
        
        // Print the memory information for the drive.
        // The memory size is defined for a drive only if it is formattable.
        if((driveInfo.iMediaAtt & KMediaAttFormattable))
                {
                TChar driveLetter;
                // if drive-list entry non-zero, drive is available
                TInt errDLetter = aFs.DriveToChar(aDriveNumber,driveLetter);
                if(errDLetter != KErrNone)
                        return;
                // The following line prints the drive letter followed by the hex value
                // of the integer indicating that drive's attributes
                printf("Drive Letter: %c\n",TUint(driveLetter));                        
        
                // Get the volume information for the formatted device.
                TVolumeInfo volumeInfo;
                TInt errVol = aFs.Volume(volumeInfo,aDriveNumber);
                if(errVol != KErrNone)
                        return;

                // Get the total size and the free space of the drive.
                TInt64 driveTotalSize = volumeInfo.iSize;
                TInt64 driveFreeSize =  volumeInfo.iFree;
                // Print the memory information for the drive.
                printf("Total size of the drive: %d\n", driveTotalSize);
                printf("Free space: %d\n", driveFreeSize);
                
                printf(" [press the enter key to continue]\n");
                // Wait for a key press.
                getchar();
                }
        
        CleanupStack::PopAndDestroy(cptr);
        }

LOCAL_C void MainL()
        {
        // The file server session.
        RFs fs;
        // Connect to the file server.
        User::LeaveIfError(fs.Connect());
        CleanupClosePushL(fs);
        printf("\nValid drives as characters (and as numbers) are:\n");

        // Initialise drive number to the first drive.
        TInt driveNumber=EDriveA;
        TChar driveLetter;

    for (; driveNumber<=EDriveZ; driveNumber++)
        {
        if (fs.IsValidDrive(driveNumber))
            {
                        // Indicates that the drive exists and is valid.
            TInt errDrive = fs.DriveToChar(driveNumber,driveLetter);
            if(errDrive == KErrNone)
                {
                                // Print the drive letter.
                    printf("%c",TUint(driveLetter));
                                // Convert the drive letter to the drive number.
                    TInt errChar = fs.CharToDrive(driveLetter, driveNumber);
                    if(errChar == KErrNone)
                        {
                                        // Print the drive number.
                            printf("(%d) ",driveNumber);
                        }
                }
            }
        }

    printf("\n");

        // Get a list of the available drives.
    TDriveList drivelist;
    User::LeaveIfError(fs.DriveList(drivelist));

        // A TDriveList (the list of available drives), is an array of
    // 26 bytes. Each byte with a non zero value signifies that the
    // corresponding drive is available.

    printf("\nUsing DriveList(), available drives are: \n");
    for (driveNumber=EDriveA; driveNumber<=EDriveZ;driveNumber++)
        {
        if (drivelist[driveNumber])
            {
                        // if drive-list entry non-zero, drive is available
            TInt errDrive = fs.DriveToChar(driveNumber,driveLetter);
            if(errDrive == KErrNone)
                {
                    // The following line prints the drive letter followed by the hex value
                    // of the integer indicating that drive's attributes
                    printf("Drive Letter: %c\n",TUint(driveLetter));
                                printf(" [press the enter key to continue]\n");
                                // Wait for a key press.
                                getchar();
                }
            }
        }
    
        printf("Memory information for formattable drives:\n");
        printf(" [press the enter key to continue]\n");
        // Wait for a key press.
        getchar();
        for (driveNumber=EDriveA; driveNumber<=EDriveZ;driveNumber++)
        {
        if (drivelist[driveNumber])
            {
                        PrintDriveInfoL(fs,driveNumber);
                        }
                }       

        CleanupStack::PopAndDestroy(&fs);
        }


GLDEF_C TInt E32Main()
        {
        // Create cleanup stack
        __UHEAP_MARK;
        CTrapCleanup* cleanup = CTrapCleanup::New();

        // Run application code inside TRAP harness, wait for key press when terminated
        TRAPD(mainError, MainL());
        if (mainError)
                {
                printf(" failed, leave code = %d", mainError);
                }

        printf(" [press the enter key to exit]\n");
        getchar();

        delete cleanup;
        __UHEAP_MARKEND;
        return KErrNone;
        }

---