examples/PIPS/hybridapp/src/hybridapp.cpp

Go to the documentation of this file.
00001 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
00002 // All rights reserved.
00003 // This component and the accompanying materials are made available
00004 // under the terms of "Eclipse Public License v1.0"
00005 // which accompanies this distribution, and is available
00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
00007 //
00008 // Initial Contributors:
00009 // Nokia Corporation - initial contribution.
00010 //
00011 // Contributors:
00012 //
00013 // Description:
00014 // Demonstrates an OE hybrid application.
00015 //
00016 
00017 
00018 
00022 #include <stdio.h>
00023 #include <f32file.h>
00024 #include <stdlib.h>
00025 #include <string.h>
00026 
00032 char* DescToChar(const TDesC& aDes)
00033         {
00034         // Get the length of the descriptor.
00035         TInt length = aDes.Length();
00036 
00037         // Allocate memory to the array of characters.
00038         // An additional byte of memory is allocated to the array as 
00039         // Symbian descriptors do not end with the end of string '\0' character.
00040         char* ptr = (char*)malloc(sizeof(char)*(length + 1));
00041         if(ptr == NULL)
00042                 {
00043                 // Return NULL if memory was not allocated properly.
00044                 return NULL;
00045                 }
00046         // The loop index.
00047         TInt ix = 0;
00048         for(; ix < length; ix++)
00049                 {
00050                 // Copy the contents of the descriptor into the array of characters.
00051                 ptr[ix] = aDes[ix];
00052                 }
00053         // Append the end of string to the 'C' style string.
00054         ptr[ix] = '\0';
00055 
00056         // return the pointer to the array.
00057         return ptr;
00058         }
00059 
00065 void PrintDriveInfoL(const RFs& aFs, const TInt aDriveNumber)
00066         {
00067         // Get the drive information
00068         TDriveInfo driveInfo;
00069         TInt errDrive = aFs.Drive(driveInfo,aDriveNumber);
00070         if(errDrive != KErrNone)
00071                 return;
00072 
00073         // Get the name of the drive.
00074         TBuf<KMaxFileName> driveName;
00075         TInt errName = aFs.GetDriveName(aDriveNumber,driveName);
00076         if(errName != KErrNone)
00077                 return;
00078 
00079         // Convert the drive name from native Symbian descriptor string to a 'C' string.
00080         char* cptr = DescToChar(driveName);
00081         CleanupStack::PushL(cptr);
00082         // Check if a name has been specified for the drive.
00083         if(strlen(cptr))
00084                 {
00085                 // Print the name of the drive.
00086                 printf("Drive Name :%s\n",cptr);
00087                 }
00088         
00089         // Print the memory information for the drive.
00090         // The memory size is defined for a drive only if it is formattable.
00091         if((driveInfo.iMediaAtt & KMediaAttFormattable))
00092                 {
00093                 TChar driveLetter;
00094                 // if drive-list entry non-zero, drive is available
00095                 TInt errDLetter = aFs.DriveToChar(aDriveNumber,driveLetter);
00096                 if(errDLetter != KErrNone)
00097                         return;
00098                 // The following line prints the drive letter followed by the hex value
00099                 // of the integer indicating that drive's attributes
00100                 printf("Drive Letter: %c\n",TUint(driveLetter));                        
00101         
00102                 // Get the volume information for the formatted device.
00103                 TVolumeInfo volumeInfo;
00104                 TInt errVol = aFs.Volume(volumeInfo,aDriveNumber);
00105                 if(errVol != KErrNone)
00106                         return;
00107 
00108                 // Get the total size and the free space of the drive.
00109                 TInt64 driveTotalSize = volumeInfo.iSize;
00110                 TInt64 driveFreeSize =  volumeInfo.iFree;
00111                 // Print the memory information for the drive.
00112                 printf("Total size of the drive: %d\n", driveTotalSize);
00113                 printf("Free space: %d\n", driveFreeSize);
00114                 
00115                 printf(" [press the enter key to continue]\n");
00116                 // Wait for a key press.
00117                 getchar();
00118                 }
00119         
00120         CleanupStack::PopAndDestroy(cptr);
00121         }
00122 
00123 LOCAL_C void MainL()
00124         {
00125         // The file server session.
00126         RFs fs;
00127         // Connect to the file server.
00128         User::LeaveIfError(fs.Connect());
00129         CleanupClosePushL(fs);
00130         printf("\nValid drives as characters (and as numbers) are:\n");
00131 
00132         // Initialise drive number to the first drive.
00133         TInt driveNumber=EDriveA;
00134         TChar driveLetter;
00135 
00136     for (; driveNumber<=EDriveZ; driveNumber++)
00137         {
00138         if (fs.IsValidDrive(driveNumber))
00139             {
00140                         // Indicates that the drive exists and is valid.
00141             TInt errDrive = fs.DriveToChar(driveNumber,driveLetter);
00142             if(errDrive == KErrNone)
00143                 {
00144                                 // Print the drive letter.
00145                     printf("%c",TUint(driveLetter));
00146                                 // Convert the drive letter to the drive number.
00147                     TInt errChar = fs.CharToDrive(driveLetter, driveNumber);
00148                     if(errChar == KErrNone)
00149                         {
00150                                         // Print the drive number.
00151                             printf("(%d) ",driveNumber);
00152                         }
00153                 }
00154             }
00155         }
00156 
00157     printf("\n");
00158 
00159         // Get a list of the available drives.
00160     TDriveList drivelist;
00161     User::LeaveIfError(fs.DriveList(drivelist));
00162 
00163         // A TDriveList (the list of available drives), is an array of
00164     // 26 bytes. Each byte with a non zero value signifies that the
00165     // corresponding drive is available.
00166 
00167     printf("\nUsing DriveList(), available drives are: \n");
00168     for (driveNumber=EDriveA; driveNumber<=EDriveZ;driveNumber++)
00169         {
00170         if (drivelist[driveNumber])
00171             {
00172                         // if drive-list entry non-zero, drive is available
00173             TInt errDrive = fs.DriveToChar(driveNumber,driveLetter);
00174             if(errDrive == KErrNone)
00175                 {
00176                     // The following line prints the drive letter followed by the hex value
00177                     // of the integer indicating that drive's attributes
00178                     printf("Drive Letter: %c\n",TUint(driveLetter));
00179                                 printf(" [press the enter key to continue]\n");
00180                                 // Wait for a key press.
00181                                 getchar();
00182                 }
00183             }
00184         }
00185     
00186         printf("Memory information for formattable drives:\n");
00187         printf(" [press the enter key to continue]\n");
00188         // Wait for a key press.
00189         getchar();
00190         for (driveNumber=EDriveA; driveNumber<=EDriveZ;driveNumber++)
00191         {
00192         if (drivelist[driveNumber])
00193             {
00194                         PrintDriveInfoL(fs,driveNumber);
00195                         }
00196                 }       
00197 
00198         CleanupStack::PopAndDestroy(&fs);
00199         }
00200 
00201 
00202 GLDEF_C TInt E32Main()
00203         {
00204         // Create cleanup stack
00205         __UHEAP_MARK;
00206         CTrapCleanup* cleanup = CTrapCleanup::New();
00207 
00208         // Run application code inside TRAP harness, wait for key press when terminated
00209         TRAPD(mainError, MainL());
00210         if (mainError)
00211                 {
00212                 printf(" failed, leave code = %d", mainError);
00213                 }
00214 
00215         printf(" [press the enter key to exit]\n");
00216         getchar();
00217 
00218         delete cleanup;
00219         __UHEAP_MARKEND;
00220         return KErrNone;
00221         }
00222 

Generated by  doxygen 1.6.2