TB10.1 Example Applications: examples/PIPS/hybridapp/src/hybridapp.cpp Source 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 
+