|
1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of the License "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 /** |
|
17 @file |
|
18 @publishedAll |
|
19 @released |
|
20 */ |
|
21 |
|
22 #if !defined(__F32FILE_H__) |
|
23 #define __F32FILE_H__ |
|
24 |
|
25 #if !defined(__E32BASE_H__) |
|
26 #include <e32base.h> |
|
27 #endif |
|
28 |
|
29 #if !defined(__E32SVR_H__) |
|
30 #include <e32svr.h> |
|
31 #endif |
|
32 |
|
33 #include <e32ldr.h> |
|
34 |
|
35 |
|
36 /** |
|
37 @publishedAll |
|
38 @released |
|
39 |
|
40 The session default drive. |
|
41 */ |
|
42 const TInt KDefaultDrive=KMaxTInt; |
|
43 |
|
44 |
|
45 |
|
46 |
|
47 /** |
|
48 @publishedAll |
|
49 @released |
|
50 |
|
51 Indicates a drive letter which is not in use. |
|
52 |
|
53 This is useful when scanning a drive list to find which drives are available. |
|
54 */ |
|
55 const TInt KDriveAbsent=0x00; |
|
56 |
|
57 |
|
58 |
|
59 |
|
60 /** |
|
61 @publishedAll |
|
62 @released |
|
63 |
|
64 The default value for the number of message slots passed to RFs::Connect(). |
|
65 |
|
66 @see RFs::Connect |
|
67 */ |
|
68 const TInt KFileServerDefaultMessageSlots=-1; |
|
69 |
|
70 |
|
71 |
|
72 |
|
73 /** |
|
74 @publishedAll |
|
75 @released |
|
76 |
|
77 The size of the array of TEntry items contained in a TEntryArray object. |
|
78 |
|
79 @see TEntryArray |
|
80 @see TEntry |
|
81 */ |
|
82 const TInt KEntryArraySize=(0x200*sizeof(TText)); |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 /** |
|
88 @publishedAll |
|
89 @released |
|
90 |
|
91 The character used to separate directories in the path name. |
|
92 */ |
|
93 const TInt KPathDelimiter='\\'; |
|
94 |
|
95 |
|
96 |
|
97 |
|
98 /** |
|
99 @publishedAll |
|
100 @released |
|
101 |
|
102 The character used to separate the drive letter from the path. |
|
103 */ |
|
104 const TInt KDriveDelimiter=':'; |
|
105 |
|
106 |
|
107 |
|
108 |
|
109 /** |
|
110 @publishedAll |
|
111 @released |
|
112 |
|
113 The character used to separate the filename from the extension. |
|
114 */ |
|
115 const TInt KExtDelimiter='.'; |
|
116 |
|
117 |
|
118 |
|
119 |
|
120 /** |
|
121 @publishedAll |
|
122 @released |
|
123 |
|
124 The maximum number of available drives. |
|
125 */ |
|
126 const TInt KMaxDrives=26; |
|
127 |
|
128 |
|
129 /** |
|
130 @publishedAll |
|
131 @released |
|
132 |
|
133 The maximum number of available proxy drives. |
|
134 */ |
|
135 const TInt KMaxProxyDrives=KMaxDrives-KMaxLocalDrives; |
|
136 |
|
137 |
|
138 /** |
|
139 @publishedAll |
|
140 @released |
|
141 |
|
142 Defines a modifiable buffer descriptor to contain a drive list. |
|
143 |
|
144 The descriptor has maximum length KMaxDrives, sufficient to contain |
|
145 all possible drive letters. |
|
146 |
|
147 @see RFs::DriveList |
|
148 @see KMaxDrives |
|
149 */ |
|
150 typedef TBuf8<KMaxDrives> TDriveList; |
|
151 |
|
152 |
|
153 |
|
154 /** |
|
155 @publishedAll |
|
156 @released |
|
157 |
|
158 The maximum length of a drivename. |
|
159 |
|
160 Sufficient for a drive letter and colon. |
|
161 */ |
|
162 const TInt KMaxDriveName=0x02; |
|
163 |
|
164 |
|
165 |
|
166 |
|
167 /** |
|
168 @publishedAll |
|
169 @released |
|
170 |
|
171 Defines a modifiable buffer descriptor to contain a drive name. |
|
172 |
|
173 A drive name comprises a drive letter (A through Z) and a colon. |
|
174 KMaxDriveName (2 bytes) is sufficient for a drive letter and colon. |
|
175 |
|
176 @see TDriveUnit::Name |
|
177 @see KMaxDriveName |
|
178 */ |
|
179 typedef TBuf<KMaxDriveName> TDriveName; |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 /** |
|
185 @publishedAll |
|
186 @released |
|
187 |
|
188 The maximum length of a file system name or file system sub type name. |
|
189 32 characters is sufficient for a file system or sub type name. |
|
190 */ |
|
191 const TInt KMaxFSNameLength=0x0020; |
|
192 |
|
193 |
|
194 |
|
195 |
|
196 /** |
|
197 @publishedAll |
|
198 @released |
|
199 |
|
200 Defines a modifiable buffer descriptor to contain a file system or file system sub type name. |
|
201 |
|
202 @see KMaxFSNameLength |
|
203 */ |
|
204 typedef TBuf<KMaxFSNameLength> TFSName; |
|
205 |
|
206 |
|
207 |
|
208 |
|
209 /** |
|
210 @publishedAll |
|
211 @released |
|
212 |
|
213 File/directory attribute: any file without the hidden or system attribute. |
|
214 */ |
|
215 const TUint KEntryAttNormal=0x0000; |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 /** |
|
221 @publishedAll |
|
222 @released |
|
223 |
|
224 File/directory attribute: read-only file or directory. |
|
225 */ |
|
226 const TUint KEntryAttReadOnly=0x0001; |
|
227 |
|
228 |
|
229 |
|
230 |
|
231 /** |
|
232 @publishedAll |
|
233 @released |
|
234 |
|
235 File/directory attribute: hidden file or directory. |
|
236 */ |
|
237 const TUint KEntryAttHidden=0x0002; |
|
238 |
|
239 |
|
240 |
|
241 |
|
242 /** |
|
243 @publishedAll |
|
244 @released |
|
245 |
|
246 File/directory attribute: system file. |
|
247 */ |
|
248 const TUint KEntryAttSystem=0x0004; |
|
249 |
|
250 |
|
251 |
|
252 |
|
253 /** |
|
254 @publishedAll |
|
255 @released |
|
256 |
|
257 File/directory attribute: volume name directory. |
|
258 */ |
|
259 const TUint KEntryAttVolume=0x0008; |
|
260 |
|
261 |
|
262 |
|
263 |
|
264 /** |
|
265 @publishedAll |
|
266 @released |
|
267 |
|
268 File/directory attribute: a directory without the hidden or system attribute. |
|
269 */ |
|
270 const TUint KEntryAttDir=0x0010; |
|
271 |
|
272 |
|
273 |
|
274 |
|
275 /** |
|
276 @publishedAll |
|
277 @released |
|
278 |
|
279 File/directory attribute: an archive file. |
|
280 */ |
|
281 const TUint KEntryAttArchive=0x0020; |
|
282 |
|
283 |
|
284 |
|
285 |
|
286 /** |
|
287 @publishedAll |
|
288 @released |
|
289 |
|
290 File/directory attribute: ROM eXecute In Place file |
|
291 */ |
|
292 const TUint KEntryAttXIP=0x0080; |
|
293 |
|
294 |
|
295 |
|
296 |
|
297 /** |
|
298 @publishedAll |
|
299 @released |
|
300 |
|
301 This file attribute bit is set if the file exists only on a remote file |
|
302 system and is not locally cached. |
|
303 |
|
304 Due to the potential high-latency of remote file systems, applications |
|
305 (or users of applications) may make use of this bit to modify their |
|
306 behaviour when working with remote files. |
|
307 |
|
308 This is a read-only attribute, so any attempt to set this attribute will |
|
309 will be ignored. |
|
310 */ |
|
311 const TUint KEntryAttRemote=0x0100; |
|
312 |
|
313 |
|
314 |
|
315 |
|
316 /** |
|
317 @publishedAll |
|
318 @released |
|
319 |
|
320 The range of entry attributes reserved for file-system specific meanings. |
|
321 File systems may assign meaning to these bits, but their definition will |
|
322 not be supported nor maintained by Symbian. |
|
323 |
|
324 All other file attribute bits are reserved for use by Symbian. |
|
325 |
|
326 The following table summarises the assignment of attribute bits: |
|
327 |
|
328 0 - KEntryAttReadOnly |
|
329 1 - KEntryAttHidden |
|
330 2 - KEntryAttSystem |
|
331 3 - KEntryAttVolume |
|
332 |
|
333 4 - KEntryAttDir |
|
334 6 - KEntryAttArchive |
|
335 7 - KEntryAttXIP |
|
336 |
|
337 8 - KEntryAttRemote |
|
338 9 - Reserved |
|
339 10 - Reserved |
|
340 11 - Reserved |
|
341 |
|
342 12 - Reserved |
|
343 13 - Reserved |
|
344 14 - Reserved |
|
345 15 - Reserved |
|
346 |
|
347 16 - File System Specific |
|
348 17 - File System Specific |
|
349 18 - File System Specific |
|
350 19 - File System Specific |
|
351 |
|
352 20 - File System Specific |
|
353 22 - File System Specific |
|
354 22 - File System Specific |
|
355 23 - File System Specific |
|
356 |
|
357 24 - KEntryAttPacked |
|
358 25 - Reserved |
|
359 26 - Reserved |
|
360 27 - KEntryAttMatchExclude |
|
361 |
|
362 28 - KEntryAttAllowUid |
|
363 29 - Reserved |
|
364 30 - KEntryAttMatchExclusive |
|
365 31 - Reserved |
|
366 */ |
|
367 const TUint KEntryAttMaskFileSystemSpecific=0x00FF0000; |
|
368 |
|
369 |
|
370 |
|
371 |
|
372 /** |
|
373 @publishedAll |
|
374 @released |
|
375 |
|
376 Bit mask for matching file and directory entries. |
|
377 |
|
378 This mask ensures that directories and hidden and |
|
379 system files are matched. |
|
380 |
|
381 (Note that KEntryAttNormal matches all entry types except directories, hidden |
|
382 and system entries). |
|
383 |
|
384 @see RFs::GetDir |
|
385 */ |
|
386 const TUint KEntryAttMatchMask=(KEntryAttHidden|KEntryAttSystem|KEntryAttDir); |
|
387 |
|
388 |
|
389 |
|
390 |
|
391 |
|
392 /** |
|
393 @publishedAll |
|
394 @released |
|
395 |
|
396 Bit mask for matching file and directory entries. |
|
397 |
|
398 This is used when all entry types, including hidden and system files, |
|
399 but excluding the volume entry are to be matched. |
|
400 |
|
401 @see RFs::GetDir |
|
402 */ |
|
403 const TUint KEntryAttMaskSupported=0x3f; |
|
404 |
|
405 |
|
406 |
|
407 |
|
408 /** |
|
409 @publishedAll |
|
410 @released |
|
411 |
|
412 Bit mask for matching file and directory entries. |
|
413 |
|
414 This is used for exclusive matching. When OR'ed with one or more file attribute |
|
415 constants, for example, KEntryAttNormal, it ensures that only the files with |
|
416 those attributes are matched. |
|
417 When OR’ed with KEntryAttDir, directories only (not hidden or system) are matched. |
|
418 |
|
419 @see KEntryAttDir |
|
420 @see KEntryAttNormal |
|
421 @see RFs::GetDir |
|
422 */ |
|
423 const TUint KEntryAttMatchExclusive=0x40000000; |
|
424 |
|
425 |
|
426 |
|
427 |
|
428 /** |
|
429 @publishedAll |
|
430 @released |
|
431 |
|
432 Bit mask for feature manager file entries. |
|
433 |
|
434 It is used in order to identify each ROM feature set data file |
|
435 uniquely in the mount order of ROM sections. |
|
436 |
|
437 */ |
|
438 const TUint KEntryAttUnique=0x01000000; |
|
439 |
|
440 |
|
441 |
|
442 |
|
443 /** |
|
444 @publishedAll |
|
445 @released |
|
446 |
|
447 Bit mask for matching file and directory entries. |
|
448 |
|
449 It is used to exclude files or directories with certain attributes from |
|
450 directory listings. This bitmask has the opposite effect |
|
451 to KEntryAttMatchExclusive. For example: |
|
452 |
|
453 @code |
|
454 KEntryAttMatchExclude|KEntryAttReadOnly |
|
455 @endcode |
|
456 |
|
457 excludes all read only entries from the directory listing. |
|
458 |
|
459 @code |
|
460 KEntryAttMatchExclusive|KEntryAttReadOnly |
|
461 @endcode |
|
462 lists only read only entries. |
|
463 |
|
464 @see KEntryAttMatchExclusive |
|
465 @see RFs::GetDir |
|
466 */ |
|
467 const TUint KEntryAttMatchExclude=0x08000000; |
|
468 |
|
469 |
|
470 |
|
471 |
|
472 /** |
|
473 @publishedAll |
|
474 @released |
|
475 |
|
476 Bit mask for matching file and directory entries. |
|
477 |
|
478 Bit mask flag used when UID information should be included in the directory |
|
479 entry listing. |
|
480 |
|
481 @see RFs::GetDir |
|
482 */ |
|
483 const TUint KEntryAttAllowUid=0x10000000; |
|
484 |
|
485 |
|
486 |
|
487 |
|
488 /** |
|
489 @publishedAll |
|
490 @released |
|
491 |
|
492 Indicates that a TEntry (that is generally returned from a TEntryArray) is |
|
493 stored in packed format where the iSizeHigh and iReserved fields follow the |
|
494 valid characters of the name string. Before accessing the aforementioned |
|
495 members, the entry must be unpacked. |
|
496 |
|
497 */ |
|
498 const TUint KEntryAttPacked = 0x01000000; |
|
499 |
|
500 |
|
501 /** |
|
502 @publishedAll |
|
503 @released |
|
504 */ |
|
505 const TUint KMaxMapsPerCall = 0x8; |
|
506 |
|
507 |
|
508 |
|
509 |
|
510 enum TNotifyType |
|
511 /** |
|
512 @publishedAll |
|
513 @released |
|
514 |
|
515 A set of change notification flags. |
|
516 |
|
517 These flags indicate the kind of change that should result in notification. |
|
518 |
|
519 This is useful for programs that maintain displays of file lists that |
|
520 must be dynamically updated. |
|
521 |
|
522 @see RFs::NotifyChange |
|
523 @see RFs |
|
524 @see RFile |
|
525 @see RRawDisk |
|
526 */ |
|
527 { |
|
528 /** |
|
529 Any change, including mounting and unmounting drives. |
|
530 */ |
|
531 ENotifyAll=0x01, |
|
532 |
|
533 |
|
534 /** |
|
535 Addition or deletion of a directory entry, or changing or formatting a disk. |
|
536 */ |
|
537 ENotifyEntry=0x02, |
|
538 |
|
539 |
|
540 /** |
|
541 Change resulting from file requests: |
|
542 RFile::Create(), RFile::Replace(), RFile::Rename(), RFs::Delete(), |
|
543 RFs::Replace(), and RFs::Rename(). |
|
544 */ |
|
545 ENotifyFile=0x04, |
|
546 |
|
547 |
|
548 /** |
|
549 Change resulting from directory requests: |
|
550 RFs::MkDir(), RFs::RmDir(), and RFs::Rename(). |
|
551 */ |
|
552 ENotifyDir=0x08, |
|
553 |
|
554 |
|
555 /** |
|
556 Change resulting from: RFs::SetEntry(), RFile::Set(), RFile::SetAtt(), |
|
557 RFile::SetModified() and RFile::SetSize() requests. |
|
558 */ |
|
559 ENotifyAttributes=0x10, |
|
560 |
|
561 |
|
562 /** |
|
563 Change resulting from the RFile::Write() request. |
|
564 */ |
|
565 ENotifyWrite=0x20, |
|
566 |
|
567 |
|
568 /** |
|
569 Change resulting from the RRawDisk::Write() request. |
|
570 */ |
|
571 ENotifyDisk=0x40 |
|
572 }; |
|
573 |
|
574 /** |
|
575 @publishedAll |
|
576 @released |
|
577 |
|
578 Notification modes for safe media removal notification API |
|
579 |
|
580 @see RFs::NotifyDismount |
|
581 */ |
|
582 enum TNotifyDismountMode |
|
583 { |
|
584 /** Used by a client to register for notification of pending dismount. This is the default behaviour for RFs::NotifyDismount*/ |
|
585 EFsDismountRegisterClient=0x01, |
|
586 |
|
587 /** |
|
588 Used for graceful file system dismounting with notifying clients of a pending dismount. |
|
589 If all clients have responded by RFs::AllowDismount(), the file system will be dismounted. |
|
590 */ |
|
591 EFsDismountNotifyClients=0x02, |
|
592 |
|
593 /** Used to forcibly dismount the file system without notifying clients. */ |
|
594 EFsDismountForceDismount=0x03, |
|
595 }; |
|
596 |
|
597 |
|
598 enum TFileCacheFlags |
|
599 /** |
|
600 @publishedAll |
|
601 @released |
|
602 |
|
603 Flags used to enable file server drive-specific caching |
|
604 */ |
|
605 { |
|
606 /** |
|
607 Enable read caching - if file explicitly opened in EFileReadBuffered mode |
|
608 */ |
|
609 EFileCacheReadEnabled = 0x01, |
|
610 |
|
611 /** |
|
612 Enable read caching for all files, regardless of file open mode |
|
613 */ |
|
614 EFileCacheReadOn = 0x02, |
|
615 |
|
616 /** |
|
617 Enable read-ahead caching - if file explicitly opened in EFileReadAheadOn mode |
|
618 */ |
|
619 EFileCacheReadAheadEnabled = 0x04, |
|
620 |
|
621 /** |
|
622 Enable read-ahead caching, regardless of file open mode |
|
623 */ |
|
624 EFileCacheReadAheadOn = 0x08, |
|
625 |
|
626 /** |
|
627 Enable write caching, if file explicitly opened in EFileWriteBuffered mode |
|
628 */ |
|
629 EFileCacheWriteEnabled = 0x10, |
|
630 |
|
631 /** |
|
632 Enable write caching for all files, regardless of file open mode |
|
633 */ |
|
634 EFileCacheWriteOn = 0x20, |
|
635 }; |
|
636 |
|
637 /** |
|
638 @publishedAll |
|
639 @released |
|
640 |
|
641 Commands to query specific volume information. |
|
642 |
|
643 @see TVolumeIOParamInfo |
|
644 */ |
|
645 enum TQueryVolumeInfoExtCmd |
|
646 { |
|
647 /** |
|
648 Queries the sub type of the file system mounted on a specified volume. |
|
649 For example, FAT12, FAT16 or FAT32. |
|
650 */ |
|
651 EFileSystemSubType, |
|
652 |
|
653 /** |
|
654 Queries the I/O parameters of a specificed volume. |
|
655 This includes the block size, the cluster size and the recommended read and write sizes for the media. |
|
656 */ |
|
657 EIOParamInfo, |
|
658 |
|
659 /** |
|
660 This command determines whether the volume is synchronous or asynchronous. |
|
661 A boolean value is returned within the buffer defined as TPckgBuf<TBool>. |
|
662 ETrue for Synchronous and EFalse for Asynchronous. |
|
663 */ |
|
664 EIsDriveSync, |
|
665 |
|
666 /** |
|
667 Query if the given drive is finalised. See RFs::FinaliseDrive() |
|
668 Not all file systems may support this query. |
|
669 A boolean value is returned within the buffer defined as TPckgBuf<TBool>. |
|
670 ETrue value means that the drive is finalised |
|
671 */ |
|
672 EIsDriveFinalised, |
|
673 }; |
|
674 |
|
675 /** |
|
676 @publishedAll |
|
677 @released |
|
678 |
|
679 Volume IO parameter information. |
|
680 |
|
681 This class is used to return IO parameter information for a specified volume. |
|
682 |
|
683 The volume parameter information holds recommended buffer sizes for the creation of efficient buffers for |
|
684 reading and writing. |
|
685 |
|
686 @see RFs::VolumeIOParam() |
|
687 */ |
|
688 class TVolumeIOParamInfo |
|
689 { |
|
690 public: |
|
691 /** |
|
692 The size of a block in bytes. |
|
693 |
|
694 Reads and writes that are aligned on block boundaries are up to twice as fast as when |
|
695 mis-aligned. |
|
696 |
|
697 Read and write operations on certain underlying media is done in blocks. |
|
698 A write operation that modifies only part of a block is less efficient, in general, than |
|
699 one that modifies an entire block. Data throughput degrades linearly for reads and writes in smaller |
|
700 sized units. |
|
701 */ |
|
702 TInt iBlockSize; |
|
703 /** |
|
704 The size in bytes of a single disk cluster. |
|
705 |
|
706 Read and write operations that are aligned on cluster boundaries are more efficient. |
|
707 |
|
708 The file system organises and allocates the file data on the disk in clusters where each cluster is |
|
709 one or more blocks. Files that are not zero length occupy at least one cluster of the disk, |
|
710 so large numbers of very small files use up more disk space than expected. |
|
711 */ |
|
712 TInt iClusterSize; |
|
713 /** |
|
714 The recommended buffer size for optimised reading performance. |
|
715 |
|
716 The given buffer size is based on sensible benchmark testing results produced by the mobile device vendor. |
|
717 The buffer size is then added to the estart.txt file |
|
718 |
|
719 The figure is included in the estart.txt file along with the drive number and the variable name. |
|
720 The example below shows the required format: |
|
721 |
|
722 [DriveC] |
|
723 RecReadBufSize 8192 |
|
724 |
|
725 When no value is provided, value KErrNotSupported is returned. |
|
726 */ |
|
727 TInt iRecReadBufSize; |
|
728 /** |
|
729 The recommended buffer size for optimised writing performance. |
|
730 |
|
731 The given buffer size is based on sensible benchmark testing results produced by the mobile device vendor. |
|
732 The buffer size is then added to the estart.txt file |
|
733 |
|
734 The figure is included in the estart.txt file along with the drive number and the variable name. |
|
735 The example below shows the required format: |
|
736 |
|
737 [DriveC] |
|
738 RecWriteBufSize 16384 |
|
739 |
|
740 When no value is provided, value KErrNotSupported is returned. |
|
741 */ |
|
742 TInt iRecWriteBufSize; |
|
743 |
|
744 |
|
745 /** |
|
746 The maximum file size that is supported by the file system mounted on this volume. |
|
747 Not all file system may provide this parameter; The value KMaxTUint64 (0xffffffffffffffff) means that this particular file system hasn't |
|
748 provided this information. |
|
749 */ |
|
750 TUint64 iMaxSupportedFileSize; |
|
751 |
|
752 private: |
|
753 /* |
|
754 Reserved space for future use |
|
755 */ |
|
756 TInt iReserved[2]; |
|
757 }; |
|
758 |
|
759 enum TDriveNumber |
|
760 /** |
|
761 @publishedAll |
|
762 @released |
|
763 |
|
764 The drive number enumeration. |
|
765 */ |
|
766 { |
|
767 EDriveA, EDriveB, EDriveC, EDriveD, EDriveE, |
|
768 EDriveF, EDriveG, EDriveH, EDriveI, EDriveJ, |
|
769 EDriveK, EDriveL, EDriveM, EDriveN, EDriveO, |
|
770 EDriveP, EDriveQ, EDriveR, EDriveS, EDriveT, |
|
771 EDriveU, EDriveV, EDriveW, EDriveX, EDriveY, |
|
772 EDriveZ |
|
773 }; |
|
774 |
|
775 |
|
776 |
|
777 |
|
778 enum TEntryKey |
|
779 /** |
|
780 @publishedAll |
|
781 @released |
|
782 |
|
783 Flags indicating the order in which directory entries are to be sorted. |
|
784 |
|
785 @see RFs::GetDir |
|
786 @see CDirScan::SetScanDataL |
|
787 @see CDir::Sort |
|
788 */ |
|
789 { |
|
790 /** |
|
791 The default; no sorting takes place |
|
792 */ |
|
793 ESortNone=0, |
|
794 |
|
795 |
|
796 /** |
|
797 Sort according to alphabetic order of file and directory name. |
|
798 |
|
799 This setting is mutually exclusive with ESortByExt, ESortBySize, |
|
800 ESortByDate and ESortByUid. |
|
801 */ |
|
802 ESortByName, |
|
803 |
|
804 |
|
805 /** |
|
806 Sort according to alphabetic order of file extension. |
|
807 |
|
808 Files without an extension take precedence over files with an extension. |
|
809 For files with the same extension or without an extension, the default is |
|
810 to sort by name. |
|
811 |
|
812 This setting is mutually exclusive with ESortByName, ESortBySize, |
|
813 ESortByDate and ESortByUid. |
|
814 */ |
|
815 ESortByExt, |
|
816 |
|
817 |
|
818 /** |
|
819 Sort according to file size. |
|
820 |
|
821 This setting is mutually exclusive with ESortByName, ESortByExt, |
|
822 ESortByDate and ESortByUid. |
|
823 */ |
|
824 ESortBySize, |
|
825 |
|
826 |
|
827 /** |
|
828 Sort according to files' last modified time and date. |
|
829 |
|
830 By default, most recent last. |
|
831 |
|
832 This setting is mutually exclusive with ESortByName, ESortByExt, |
|
833 ESortBySize and ESortByUid. |
|
834 */ |
|
835 ESortByDate, |
|
836 |
|
837 |
|
838 /** |
|
839 Sort according to file UID. |
|
840 |
|
841 This setting is mutually exclusive with ESortByName, ESortByExt, |
|
842 ESortBySize and ESortByDate. |
|
843 */ |
|
844 ESortByUid, |
|
845 |
|
846 |
|
847 /** |
|
848 Qualifies the sort order; if set, directories are listed in the order in |
|
849 which they occur. |
|
850 |
|
851 This is the default. |
|
852 |
|
853 This flag is mutually exclusive with EDirsFirst and EDirslast. |
|
854 */ |
|
855 EDirsAnyOrder=0, |
|
856 |
|
857 |
|
858 /** |
|
859 Qualifies the sort order; if set, directories come before files in sort order. |
|
860 |
|
861 This flag is mutually exclusive with EDirsAnyOrder and EDirsLast. |
|
862 */ |
|
863 EDirsFirst=0x100, |
|
864 |
|
865 |
|
866 /** |
|
867 Qualifies the sort order; if set, files come before directories in sort order. |
|
868 |
|
869 This flag is mutually exclusive with EDirsAnyOrder and EDirsFirst. |
|
870 */ |
|
871 EDirsLast=0x200, |
|
872 |
|
873 |
|
874 /** |
|
875 Qualifies the sort order; files are sorted in ascending order, i.e. from A to Z. |
|
876 This is the default behaviour. |
|
877 |
|
878 This flag is mutually exclusive with EDescending and EDirDescending. |
|
879 */ |
|
880 EAscending=0, |
|
881 |
|
882 |
|
883 /** |
|
884 Qualifies the sort order; files are sorted in descending order, i.e. from Z to A. |
|
885 |
|
886 This flag is mutually exclusive with EAscending and EDirDescending. |
|
887 */ |
|
888 EDescending=0x400, |
|
889 |
|
890 |
|
891 /** |
|
892 Qualifies the sort order; directories are sorted in descending order, i.e. from Z to A. |
|
893 |
|
894 This flag shall be used in combination with either EDirsFirst or EDirsLast. |
|
895 This flag is mutually exclusive with EAscending and EDescending. |
|
896 */ |
|
897 EDirDescending=0x800 |
|
898 }; |
|
899 |
|
900 |
|
901 |
|
902 |
|
903 enum TFileMode |
|
904 /** |
|
905 @publishedAll |
|
906 @released |
|
907 |
|
908 Access and share modes available when opening a file. |
|
909 |
|
910 The access mode indicates whether the file is opened just for reading or |
|
911 for writing. |
|
912 |
|
913 The share mode indicates whether other RFile objects can access the |
|
914 open file, and whether this access is read only. |
|
915 |
|
916 Use EFileShareReadersOrWriters if a client does not care whether the file has |
|
917 been previously opened for ReadOnly or Read/Write access. |
|
918 |
|
919 If EFileShareReadersOrWriters is not used, then a client needs to cooperate with |
|
920 other clients in order to open the file with the correct share mode, either |
|
921 EFileShareReadersOnly or EFileShareAny, depending on the share mode used when |
|
922 the file was originally opened. |
|
923 |
|
924 To open a file for reading and writing with read and write shared access, |
|
925 use: |
|
926 |
|
927 @code |
|
928 _LIT(KFilename, "filename.ext"); |
|
929 RFile file; |
|
930 file.Open(theFs, KFilename, EFileShareAny|EFileWrite); |
|
931 @endcode |
|
932 |
|
933 If another instance of RFile tries to open this file in EFileShareExclusive |
|
934 or EFileShareReadersOnly mode, access is denied. However, it can be opened |
|
935 in EFileShareAny mode or EFileShareReadersOrWriters mode. |
|
936 |
|
937 If a file is opened with EFileShareReadersOrWriters, and the file is opened for |
|
938 sharing by another client, then the file share mode is promoted to the new share |
|
939 mode. When the file handle is closed then the share mode is demoted back to |
|
940 EFileShareReadersOrWriters. |
|
941 |
|
942 @code |
|
943 |
|
944 Table of FileShare promotion rules |
|
945 ---------------------------------- |
|
946 |
|
947 Client A Client B Resultant Share Mode |
|
948 -------- -------- -------------------- |
|
949 ReadersOnly ReadersOnly ReadersOnly |
|
950 ReadersOnly ReadersOrWriters|EFileRead ReadersOnly |
|
951 ReadersOnly ReadersOrWriters|EFileWrite INCOMPATIBLE |
|
952 ReadersOnly Any INCOMPATIBLE |
|
953 |
|
954 ReadersOrWriters|EFileRead ReadersOnly ReadersOnly |
|
955 ReadersOrWriters|EFileRead ReadersOrWriters|EFileRead ReadersOrWriters |
|
956 ReadersOrWriters|EFileRead ReadersOrWriters|EFileWrite ReadersOrWriters |
|
957 ReadersOrWriters|EFileRead Any Any |
|
958 |
|
959 ReadersOrWriters|EFileWrite ReadersOnly INCOMPATIBLE |
|
960 ReadersOrWriters|EFileWrite ReadersOrWriters|EFileRead ReadersOrWriters |
|
961 ReadersOrWriters|EFileWrite ReadersOrWriters|EFileWrite ReadersOrWriters |
|
962 ReadersOrWriters|EFileWrite Any Any |
|
963 |
|
964 Any ReadersOnly INCOMPATIBLE |
|
965 Any ReadersOrWriters|EFileRead Any |
|
966 Any ReadersOrWriters|EFileWrite Any |
|
967 Any Any Any |
|
968 @endcode |
|
969 |
|
970 Use the following guidance notes for selecting FileShare mode with shared RFile objects: |
|
971 |
|
972 EFileShareAny |
|
973 - Use this mode to request both read and write access when another client needs |
|
974 to write to the file and respective client access to the file is coordinated. |
|
975 - To open a file for non-exclusive write, use EFileShareAny | EFileWrite. |
|
976 - It is recommended that either EFileShareAny or EFileShareAny | EFileRead are |
|
977 not used. These combinations will block users attempting to use the |
|
978 EFileShareReadersOnly mode even if all the EFileShareAny handles do not have |
|
979 the EFileWrite bit set as the EFileRead and EFileWrite bits have no affect on |
|
980 sharing. Use either EFileShareReadersOnly or EFileShareReadersOrWriters. |
|
981 |
|
982 EFileShareReadersOrWriters |
|
983 - Use this mode when it does not matter if another file writes to the file and |
|
984 file access can not be coordinated as other clients are unknown. |
|
985 - To open a file for shared read access whilst permitting writers, use |
|
986 EFileShareReadersOrWriters | EFileRead. |
|
987 |
|
988 - For write access with unrestricted share mode, |
|
989 EFileShareReadersOrWriters | EFileWrite may be used however |
|
990 EFilesShareAny | EFileWrite is preferred. |
|
991 |
|
992 EFileShareReadersOnly |
|
993 - Use this mode to get read access to the file and deny write access for any |
|
994 other handles on this file. |
|
995 - To open a file for shared read access whilst disallowing writers use |
|
996 EFileShareReadersOnly. |
|
997 |
|
998 |
|
999 Files may be opened in text or binary mode. Native Symbian OS application |
|
1000 files are nearly all binary, (so they will usually be opened in binary mode). |
|
1001 However, they can be opened in text mode (to support testing, and to make them |
|
1002 compatible with text formats on remote systems). |
|
1003 Symbian OS native text format uses CR-LF (ASCII 0x0d, 0x0a) to denote the end of |
|
1004 a line. When reading, however, any combination of CR, LF, LF-CR or CR-LF is |
|
1005 recognised as the end of a line. Where a remote file system uses a different |
|
1006 format, it is the responsibility of the installable file system to present |
|
1007 an interface for text files which conforms with this format. |
|
1008 |
|
1009 The share mode may be OR’ed with either EFileStream or EFileStreamText. |
|
1010 |
|
1011 Additionally, it may be OR’ed with either EFileRead or EFileWrite. |
|
1012 */ |
|
1013 { |
|
1014 /** |
|
1015 Exclusive access for the program opening the file. |
|
1016 |
|
1017 No other program can access the file until it is closed. |
|
1018 If another program is already accessing the file in any share mode, then |
|
1019 an attempt to open it with an EFileShareExclusive will fail. |
|
1020 */ |
|
1021 EFileShareExclusive, |
|
1022 |
|
1023 |
|
1024 /** |
|
1025 Read-only sharing. |
|
1026 |
|
1027 This means that the file may only be accessed for reading. |
|
1028 A file cannot be opened using a share mode of EFileShareReadersOnly with |
|
1029 an EFileWrite flag. |
|
1030 */ |
|
1031 EFileShareReadersOnly, |
|
1032 |
|
1033 |
|
1034 /** |
|
1035 Shared access for reading and writing. |
|
1036 |
|
1037 This means that other programs may share access to the file for reading |
|
1038 and writing with the program which opened the file. |
|
1039 |
|
1040 When using this mode, the program is expecting another program to be able |
|
1041 to write to the file, so is not compatible with EFileShareReadersOnly. |
|
1042 */ |
|
1043 EFileShareAny, |
|
1044 |
|
1045 |
|
1046 /** |
|
1047 Shared access for reading and writing. |
|
1048 |
|
1049 This means that other programs may share access to the file for reading |
|
1050 and writing with the program which opened the file. |
|
1051 |
|
1052 When using this mode, the program does not care if another program has |
|
1053 the file open for read or write access. |
|
1054 */ |
|
1055 EFileShareReadersOrWriters, |
|
1056 |
|
1057 |
|
1058 /** |
|
1059 For files to be opened in binary mode. |
|
1060 */ |
|
1061 EFileStream=0, |
|
1062 |
|
1063 |
|
1064 /** |
|
1065 For files to be opened in text mode. |
|
1066 */ |
|
1067 EFileStreamText=0x100, |
|
1068 |
|
1069 |
|
1070 /** |
|
1071 The file may be read from but not written to. |
|
1072 */ |
|
1073 EFileRead=0, |
|
1074 |
|
1075 |
|
1076 /** |
|
1077 The file may be read from and written to |
|
1078 |
|
1079 Cannot be combined with a share mode of EFileShareReadersOnly. |
|
1080 */ |
|
1081 EFileWrite=0x200, |
|
1082 |
|
1083 /** |
|
1084 Specifies that an asynchronous read request should not be completed |
|
1085 until all requested data becomes available. |
|
1086 |
|
1087 Cannot be combined with the EFileShareExclusive or EFileShareReadersOnly |
|
1088 share modes as this will prohibit a writer from updating the file. |
|
1089 */ |
|
1090 EFileReadAsyncAll=0x400, |
|
1091 |
|
1092 /** |
|
1093 Enables write buffering |
|
1094 */ |
|
1095 EFileWriteBuffered =0x00000800, |
|
1096 |
|
1097 /** |
|
1098 Disables write buffering |
|
1099 */ |
|
1100 EFileWriteDirectIO =0x00001000, |
|
1101 |
|
1102 /** |
|
1103 Enables read buffering |
|
1104 */ |
|
1105 EFileReadBuffered =0x00002000, |
|
1106 |
|
1107 /** |
|
1108 Disables read buffering |
|
1109 */ |
|
1110 EFileReadDirectIO =0x00004000, |
|
1111 |
|
1112 /** |
|
1113 Enables read ahead. |
|
1114 */ |
|
1115 EFileReadAheadOn =0x00008000, |
|
1116 |
|
1117 /** |
|
1118 Disables read ahead. |
|
1119 */ |
|
1120 EFileReadAheadOff =0x00010000, |
|
1121 |
|
1122 /** |
|
1123 Enable delete on close |
|
1124 */ |
|
1125 EDeleteOnClose =0x00020000, |
|
1126 |
|
1127 /** |
|
1128 Enables operations on large files. |
|
1129 |
|
1130 @internalTechnology |
|
1131 |
|
1132 */ |
|
1133 EFileBigFile =0x00040000 |
|
1134 |
|
1135 }; |
|
1136 |
|
1137 |
|
1138 |
|
1139 |
|
1140 /** |
|
1141 @publishedAll |
|
1142 @released |
|
1143 |
|
1144 Bit mask provided for retrieving a file's share mode. |
|
1145 |
|
1146 @see TFileMode |
|
1147 */ |
|
1148 const TUint KFileShareMask=0xff; |
|
1149 |
|
1150 |
|
1151 |
|
1152 |
|
1153 enum TFormatMode |
|
1154 /** |
|
1155 @publishedAll |
|
1156 @released |
|
1157 |
|
1158 The format method. |
|
1159 */ |
|
1160 { |
|
1161 /** |
|
1162 Indicates a high density floppy disk to be formatted. |
|
1163 |
|
1164 Obsolete. |
|
1165 |
|
1166 Can be ORed with EFullFormat or EQuickFormat, but does not |
|
1167 have any effect. |
|
1168 */ |
|
1169 EHighDensity, |
|
1170 |
|
1171 |
|
1172 /** |
|
1173 Indicates a low density floppy disk to be formatted. |
|
1174 |
|
1175 Obsolete. |
|
1176 |
|
1177 Can be ORed with EFullFormat or EQuickFormat, but does not |
|
1178 have any effect. |
|
1179 */ |
|
1180 ELowDensity, |
|
1181 |
|
1182 |
|
1183 /** |
|
1184 Performs a full format, erasing whole media content and creating |
|
1185 new file system layout. |
|
1186 |
|
1187 This is the default mode. |
|
1188 */ |
|
1189 EFullFormat=0, |
|
1190 |
|
1191 |
|
1192 /** |
|
1193 Performs a quick media format, erasing only required minimum media content. |
|
1194 For example, for FAT file system it resets FAT and root directory content. |
|
1195 Also preserves bad sectors if there are some on the volume. |
|
1196 */ |
|
1197 EQuickFormat=0x100, |
|
1198 |
|
1199 |
|
1200 /** |
|
1201 Indicates a custom formatting mode. In this mode some optional file system |
|
1202 specific parameters may be passed to RFormat::Open(). |
|
1203 |
|
1204 @see TLDFormatInfo |
|
1205 @see TInt RFormat::Open(RFs &aFs, const TDesC &aName, TUint aFormatMode, TInt &aCount, const TDesC8 &anInfo); |
|
1206 */ |
|
1207 ESpecialFormat=0x200, |
|
1208 |
|
1209 /** |
|
1210 Forced erase of locked media |
|
1211 */ |
|
1212 EForceErase=0x400, |
|
1213 |
|
1214 /** |
|
1215 This flag enables formatting the volume even if it has files or directories opened on it. |
|
1216 If this flag is specified, the volume will be forcedly dismounted before performing media formatting. |
|
1217 |
|
1218 Even with this flag the RFormat::Open() can fail with KErrInUse in following cases: |
|
1219 1. if there are clamped files on the volume. |
|
1220 2. there are opened "disk access" objects, like RFormat or RRawDisk on the volume. |
|
1221 */ |
|
1222 EForceFormat = 0x800, |
|
1223 |
|
1224 }; |
|
1225 |
|
1226 |
|
1227 |
|
1228 |
|
1229 enum TSeek |
|
1230 /** |
|
1231 @publishedAll |
|
1232 @released |
|
1233 |
|
1234 Flags indicating the destination of a seek operation. |
|
1235 |
|
1236 File locations are specified as a 32-bit signed integer, |
|
1237 allowing offsets of ?GB from the origin of the seek. |
|
1238 |
|
1239 @see RFile::Seek |
|
1240 */ |
|
1241 { |
|
1242 /** |
|
1243 This can only be used for file systems with execute-in-place facilities, |
|
1244 such as the ROM file system: the offset specifies the absolute address of |
|
1245 the data. |
|
1246 */ |
|
1247 ESeekAddress, |
|
1248 |
|
1249 |
|
1250 /** |
|
1251 Destination is the start of file. |
|
1252 */ |
|
1253 ESeekStart, |
|
1254 |
|
1255 |
|
1256 /** |
|
1257 Destination is the current position in file. |
|
1258 */ |
|
1259 ESeekCurrent, |
|
1260 |
|
1261 |
|
1262 /** |
|
1263 Destination is the end of file. |
|
1264 */ |
|
1265 ESeekEnd |
|
1266 }; |
|
1267 |
|
1268 /** |
|
1269 @publishedAll |
|
1270 @released |
|
1271 |
|
1272 */ |
|
1273 class TBlockMapEntry : public TBlockMapEntryBase |
|
1274 { |
|
1275 public: |
|
1276 IMPORT_C TBlockMapEntry(); |
|
1277 IMPORT_C void SetNumberOfBlocks( TUint aNumberOfBlocks ); |
|
1278 IMPORT_C void SetStartBlock( TUint aStartBlock ); |
|
1279 }; |
|
1280 |
|
1281 /** |
|
1282 @publishedAll |
|
1283 @released |
|
1284 |
|
1285 */ |
|
1286 typedef TBuf8<KMaxMapsPerCall*sizeof(TBlockMapEntry)> TBlockArrayDes; |
|
1287 |
|
1288 struct SBlockMapInfo : public SBlockMapInfoBase |
|
1289 { |
|
1290 TBlockArrayDes iMap; |
|
1291 }; |
|
1292 |
|
1293 /** |
|
1294 @publishedAll |
|
1295 @released |
|
1296 */ |
|
1297 enum TBlockMapUsage |
|
1298 { |
|
1299 /* */ |
|
1300 EBlockMapUsagePaging, |
|
1301 /* */ |
|
1302 ETestDebug |
|
1303 }; |
|
1304 |
|
1305 class TEntry |
|
1306 /** |
|
1307 @publishedAll |
|
1308 @released |
|
1309 |
|
1310 Encapsulates an entry in a directory, which can be another (nested) directory, |
|
1311 a file or a volume label. |
|
1312 |
|
1313 Each directory entry has a name which is relative to its owning directory |
|
1314 and a type, which is indicated by its unique identifier (UID). |
|
1315 |
|
1316 An entry can be interrogated for the following properties: |
|
1317 |
|
1318 1. the kind of entry: stored in the entry UIDs, stored in iType |
|
1319 |
|
1320 2. the entry attributes, stored in iAtt |
|
1321 |
|
1322 3. the size of entry |
|
1323 |
|
1324 4. the time the entry was last modified. |
|
1325 |
|
1326 @see RDir |
|
1327 @see RFs::Entry |
|
1328 @see RFs::SetEntry |
|
1329 @see CfileBase::CurrentEntry |
|
1330 */ |
|
1331 { |
|
1332 public: |
|
1333 IMPORT_C TEntry(); |
|
1334 IMPORT_C TEntry(const TEntry& aEntry); |
|
1335 IMPORT_C TEntry& operator=(const TEntry& aEntry); |
|
1336 IMPORT_C TBool IsReadOnly() const; |
|
1337 IMPORT_C TBool IsHidden() const; |
|
1338 IMPORT_C TBool IsSystem() const; |
|
1339 IMPORT_C TBool IsDir() const; |
|
1340 IMPORT_C TBool IsArchive() const; |
|
1341 inline const TUid& operator[](TInt anIndex) const; |
|
1342 inline TBool IsUidPresent(TUid aUid) const; |
|
1343 inline TBool IsTypeValid() const; |
|
1344 inline TUid MostDerivedUid() const; |
|
1345 IMPORT_C TInt64 FileSize() const; |
|
1346 inline void SetFileSize(TInt64 aFileSize); |
|
1347 |
|
1348 private: |
|
1349 inline void Copy(const TEntry& aEntry); |
|
1350 inline void Unpack(); |
|
1351 |
|
1352 public: |
|
1353 /** |
|
1354 The individual bits within this byte indicate which attributes |
|
1355 have been set. |
|
1356 |
|
1357 @see KEntryAttNormal |
|
1358 @see KEntryAttReadOnly |
|
1359 @see KEntryAttHidden |
|
1360 @see KEntryAttSystem |
|
1361 */ |
|
1362 TUint iAtt; |
|
1363 |
|
1364 |
|
1365 /** |
|
1366 The size of the file in bytes. |
|
1367 For files larger that 2G it must be cast to TUint in order to avoid looking like negative signed. |
|
1368 */ |
|
1369 TInt iSize; |
|
1370 |
|
1371 |
|
1372 /** |
|
1373 The local time of last modification. |
|
1374 */ |
|
1375 TTime iModified; |
|
1376 |
|
1377 |
|
1378 /** |
|
1379 The file's UIDtype |
|
1380 */ |
|
1381 TUidType iType; |
|
1382 |
|
1383 |
|
1384 /** |
|
1385 The name of the file relative to the owning directory, |
|
1386 with a maximum of KMaxFileName characters. |
|
1387 |
|
1388 @see KMaxFileName |
|
1389 */ |
|
1390 TBufC<KMaxFileName> iName; |
|
1391 |
|
1392 private: |
|
1393 TUint32 iSizeHigh; |
|
1394 /** |
|
1395 Reserved for future expansion |
|
1396 */ |
|
1397 TUint32 iReserved; |
|
1398 }; |
|
1399 |
|
1400 |
|
1401 |
|
1402 |
|
1403 class RDir; |
|
1404 class TEntryArray |
|
1405 /** |
|
1406 @publishedAll |
|
1407 @released |
|
1408 |
|
1409 Array of directory entries. |
|
1410 |
|
1411 It contains the results of a call to RDir::Read(): it will contain all |
|
1412 the TEntry items in the directory. Thus, a directory can be read in |
|
1413 a single call, minimising client/server communication overheads. |
|
1414 |
|
1415 @see TEntry |
|
1416 @see RDir::Read |
|
1417 */ |
|
1418 { |
|
1419 public: |
|
1420 IMPORT_C TEntryArray(); |
|
1421 IMPORT_C TInt Count() const; |
|
1422 IMPORT_C const TEntry& operator[](TInt anIndex) const; |
|
1423 private: |
|
1424 TInt iCount; |
|
1425 TInt iIndex; |
|
1426 const TEntry* iPos; |
|
1427 TBuf8<KEntryArraySize> iBuf; |
|
1428 friend class RDir; |
|
1429 friend class RFs; |
|
1430 friend class TRawEntryArray; |
|
1431 }; |
|
1432 |
|
1433 |
|
1434 |
|
1435 |
|
1436 class TDriveInfo |
|
1437 /** |
|
1438 @publishedAll |
|
1439 @released |
|
1440 |
|
1441 Contains drive information. |
|
1442 |
|
1443 @see RFs::Drive |
|
1444 */ |
|
1445 { |
|
1446 public: |
|
1447 /** |
|
1448 The type of media mounted on the drive. |
|
1449 */ |
|
1450 TMediaType iType; |
|
1451 |
|
1452 |
|
1453 /** |
|
1454 Indicates whether the drive supports a battery, and if so, its state. |
|
1455 */ |
|
1456 TBatteryState iBattery; |
|
1457 |
|
1458 |
|
1459 /** |
|
1460 The drive attributes. |
|
1461 |
|
1462 @see KDriveAttLocal |
|
1463 @see KDriveAttRom |
|
1464 @see KDriveAttRedirected |
|
1465 @see KDriveAttSubsted |
|
1466 @see KDriveAttInternal |
|
1467 @see KDriveAttRemovable |
|
1468 */ |
|
1469 TUint iDriveAtt; |
|
1470 |
|
1471 |
|
1472 /** |
|
1473 The attributes of the media mounted on the drive. |
|
1474 |
|
1475 @see KMediaAttVariableSize |
|
1476 @see KMediaAttDualDensity |
|
1477 @see KMediaAttFormattable |
|
1478 @see KMediaAttWriteProtected |
|
1479 @see KMediaAttLockable |
|
1480 @see KMediaAttLocked |
|
1481 */ |
|
1482 TUint iMediaAtt; |
|
1483 private: |
|
1484 /** |
|
1485 Reserved for future expansion |
|
1486 */ |
|
1487 TUint32 iReserved; |
|
1488 }; |
|
1489 |
|
1490 |
|
1491 |
|
1492 |
|
1493 class TVolumeInfo |
|
1494 /** |
|
1495 @publishedAll |
|
1496 @released |
|
1497 |
|
1498 Contains information about a volume mounted on a drive. Use RFs::Drive() if only |
|
1499 the drive information is required. |
|
1500 |
|
1501 If a drive supports removable media it may contain different volumes over time. |
|
1502 |
|
1503 Volume information is made up of information concerning the drive on which it is mounted, |
|
1504 which can also be accessed through RFs::Drive(), and the volume information, this is made |
|
1505 up of the size of the volume, the free space, its unique identifying number and a name. |
|
1506 |
|
1507 TVolumeInfo is initialised by RFs::Volume(). |
|
1508 |
|
1509 @see RFs::Volume() |
|
1510 @see RFs::Drive() |
|
1511 */ |
|
1512 { |
|
1513 public: |
|
1514 IMPORT_C TVolumeInfo(); |
|
1515 |
|
1516 /** |
|
1517 Information about the drive on which the volume is mounted. |
|
1518 |
|
1519 @see TDriveInfo |
|
1520 */ |
|
1521 TDriveInfo iDrive; |
|
1522 |
|
1523 |
|
1524 /** |
|
1525 The volume’s unique identifying number. |
|
1526 */ |
|
1527 TUint iUniqueID; |
|
1528 |
|
1529 |
|
1530 /** |
|
1531 The maximum size of the volume in bytes. The current amount of memory |
|
1532 in use plus the amount of free memory. |
|
1533 */ |
|
1534 TInt64 iSize; |
|
1535 |
|
1536 |
|
1537 /** |
|
1538 The amount of free space on the volume in bytes. |
|
1539 */ |
|
1540 TInt64 iFree; |
|
1541 |
|
1542 |
|
1543 /** |
|
1544 Name of the volume, with a maximum of KMaxFileName characters. |
|
1545 |
|
1546 This field is optional. |
|
1547 |
|
1548 @see KMaxFileName |
|
1549 */ |
|
1550 TBufC<KMaxFileName> iName; |
|
1551 |
|
1552 /** |
|
1553 Flags which define the default file-caching behaviour for this volume |
|
1554 |
|
1555 @see TFileCacheFlags |
|
1556 */ |
|
1557 TFileCacheFlags iFileCacheFlags; |
|
1558 |
|
1559 /** |
|
1560 @prototype |
|
1561 @internalTechnology |
|
1562 Internal flag, used in the case of non-blocking getting volume information. |
|
1563 @see RFs::Volume(TVolumeInfo& aVol,TInt aDrive, TRequestStatus& aStat) |
|
1564 |
|
1565 If this flag is set, it means that the volume information will be obtained |
|
1566 asynchronously. More specific, on return iFree will reflect the _current_ amount of free space on volume at the moment of |
|
1567 RFs::Volume() call, not the exact final value. This is because in this case getting volume information will be asynchronous, |
|
1568 and the client will not be suspended until the mount finish calculating free space. At present appicable to FAT32 file system only. |
|
1569 */ |
|
1570 TUint8 iVolSizeAsync : 1; |
|
1571 |
|
1572 private: |
|
1573 /** |
|
1574 Reserved for future expansion |
|
1575 */ |
|
1576 TUint8 i8Reserved1; |
|
1577 TUint16 i16Reserved1; |
|
1578 TUint32 i32Reserved1; |
|
1579 TUint32 i32Reserved2; |
|
1580 }; |
|
1581 |
|
1582 |
|
1583 |
|
1584 |
|
1585 class TDriveUnit |
|
1586 /** |
|
1587 @publishedAll |
|
1588 @released |
|
1589 |
|
1590 Drive numbers and letters. |
|
1591 |
|
1592 A drive may be represented by either an integer between zero and twenty five |
|
1593 inclusive, or by a buffer descriptor containing a character between "A" and "Z" |
|
1594 inclusive, followed by a colon. |
|
1595 This class encapsulates both representations. |
|
1596 An instance of this class is constructed specifying either the drive number |
|
1597 or the drive letter and may be converted between the two representations. |
|
1598 */ |
|
1599 { |
|
1600 public: |
|
1601 inline TDriveUnit() {}; |
|
1602 IMPORT_C TDriveUnit(TInt aDrive); |
|
1603 IMPORT_C TDriveUnit(const TDesC& aDrive); |
|
1604 IMPORT_C TDriveUnit& operator=(TInt aDrive); |
|
1605 IMPORT_C TDriveUnit& operator=(const TDesC& aDrive); |
|
1606 inline operator TInt() const; |
|
1607 IMPORT_C TDriveName Name() const; |
|
1608 private: |
|
1609 TInt iDrive; |
|
1610 }; |
|
1611 |
|
1612 |
|
1613 |
|
1614 |
|
1615 class RFs; |
|
1616 // |
|
1617 class TParseBase |
|
1618 /** |
|
1619 @publishedAll |
|
1620 @released |
|
1621 |
|
1622 Base class for file name parsing. |
|
1623 |
|
1624 You first need to set up the path to be parsed using either a TParse, TParsePtr |
|
1625 or TParsePtrC object. |
|
1626 |
|
1627 The interrogation and extraction functions in this class allow you to test |
|
1628 whether a component has been specified in the pathname, and if so, |
|
1629 to extract it. If a component is not present in the pathname, |
|
1630 the extraction function returns an empty string. |
|
1631 |
|
1632 This class also allows directories to be added to, and popped from the path. |
|
1633 |
|
1634 Notes: |
|
1635 |
|
1636 1. the filename modification functions cannot be used by the TParsePtrC class. |
|
1637 |
|
1638 2. navigation using .. and . is not supported. |
|
1639 |
|
1640 @see TParse |
|
1641 @see TParsePtr |
|
1642 @see TParsePtrC |
|
1643 */ |
|
1644 { |
|
1645 private: |
|
1646 struct SField {TUint8 pos;TUint8 len;TUint8 present;TUint8 filler;}; |
|
1647 enum TField {EDrive,EPath,EName,EExt,EMaxFields}; |
|
1648 enum TWild {EWildName=0x01,EWildExt=0x02,EWildEither=0x04,EIsRoot=0x08,EWildIsKMatchOne=0x10,EWildIsKMatchAny=0x20}; |
|
1649 public: |
|
1650 IMPORT_C TParseBase(); |
|
1651 IMPORT_C TInt PopDir(); |
|
1652 IMPORT_C TInt AddDir(const TDesC& aName); |
|
1653 IMPORT_C const TDesC& FullName() const; |
|
1654 IMPORT_C TPtrC Drive() const; |
|
1655 IMPORT_C TPtrC Path() const; |
|
1656 IMPORT_C TPtrC DriveAndPath() const; |
|
1657 IMPORT_C TPtrC Name() const; |
|
1658 IMPORT_C TPtrC Ext() const; |
|
1659 IMPORT_C TPtrC NameAndExt() const; |
|
1660 IMPORT_C TBool DrivePresent() const; |
|
1661 IMPORT_C TBool PathPresent() const; |
|
1662 IMPORT_C TBool NamePresent() const; |
|
1663 IMPORT_C TBool ExtPresent() const; |
|
1664 IMPORT_C TBool NameOrExtPresent() const; |
|
1665 IMPORT_C TBool IsRoot() const; |
|
1666 IMPORT_C TBool IsWild() const; |
|
1667 IMPORT_C TBool IsKMatchOne() const; |
|
1668 IMPORT_C TBool IsKMatchAny() const; |
|
1669 IMPORT_C TBool IsNameWild() const; |
|
1670 IMPORT_C TBool IsExtWild() const; |
|
1671 protected: |
|
1672 virtual TDes& NameBuf() = 0; // Reference to derived class descriptor containing the filename. |
|
1673 virtual const TDesC& NameBufC() const = 0; // const reference to derived class descriptor containing the filename. |
|
1674 TInt Set(const TDesC* aName,const TDesC* aRelated,const TDesC* aDefault,TBool allowWild); |
|
1675 private: |
|
1676 TInt ParseDrive(TLex& aName,TBool& aDone); |
|
1677 TInt ParsePath(TLex& aName,TBool& aDone); |
|
1678 TInt ParseName(TLex& aName,TBool& aDone); |
|
1679 TInt ParseExt(TLex& aName,TBool& aDone); |
|
1680 protected: |
|
1681 TInt16 iMod; // Non-zero indicates File name modification functionality is enabled. |
|
1682 private: |
|
1683 TInt16 iWild; |
|
1684 SField iField[EMaxFields]; |
|
1685 }; |
|
1686 |
|
1687 |
|
1688 |
|
1689 |
|
1690 class TParsePtr : public TParseBase |
|
1691 /** |
|
1692 @publishedAll |
|
1693 @released |
|
1694 |
|
1695 Parses filenames using less space on the stack than TParse. |
|
1696 |
|
1697 Stores a reference to a filename, unlike TParse, which uses |
|
1698 a 512 byte TFileName object as an internal buffer to store |
|
1699 a copy of the filename. |
|
1700 The filename's components (drive, path, etc.) can be retrieved using |
|
1701 the functions provided by the base class, TParseBase. |
|
1702 This class should be used in preference to TParse when minimising stack |
|
1703 usage is a priority. |
|
1704 |
|
1705 @see TParse |
|
1706 @see TFileName |
|
1707 */ |
|
1708 { |
|
1709 public: |
|
1710 IMPORT_C TParsePtr(TDes& aName); |
|
1711 protected: |
|
1712 IMPORT_C TDes& NameBuf(); |
|
1713 IMPORT_C const TDesC& NameBufC() const; |
|
1714 private: |
|
1715 TPtr iNameBuf; |
|
1716 }; |
|
1717 |
|
1718 |
|
1719 |
|
1720 |
|
1721 class TParsePtrC : public TParseBase |
|
1722 /** |
|
1723 @publishedAll |
|
1724 @released |
|
1725 |
|
1726 Parses, but cannot modify, filenames using less space on the stack than TParse. |
|
1727 |
|
1728 Stores a reference to a filename, unlike TParse, which uses |
|
1729 a 512 byte TFileName object as an internal buffer to store |
|
1730 a copy of the filename. |
|
1731 The filename's components (drive, path, etc.) can be retrieved using |
|
1732 the functions provided by the base class, TParseBase. |
|
1733 Note that because the filename cannot be modified through this class, |
|
1734 the base class functions PopDir() and AddDir() cannot be called, because |
|
1735 a panic will be raised. |
|
1736 |
|
1737 @see TParse |
|
1738 @see TFileName |
|
1739 */ |
|
1740 { |
|
1741 public: |
|
1742 IMPORT_C TParsePtrC(const TDesC& aName); |
|
1743 protected: |
|
1744 IMPORT_C TDes& NameBuf(); |
|
1745 IMPORT_C const TDesC& NameBufC() const; |
|
1746 private: |
|
1747 TPtrC iNameBuf; |
|
1748 }; |
|
1749 |
|
1750 |
|
1751 |
|
1752 |
|
1753 class TParse : public TParseBase |
|
1754 /** |
|
1755 @publishedAll |
|
1756 @released |
|
1757 |
|
1758 Parses filenames. |
|
1759 |
|
1760 The class uses the full filename structure supported by Symbian OS. |
|
1761 |
|
1762 TParse works by using the Set() function to set up the filename to be parsed. |
|
1763 Then, various getter functions defined in the base class, TParseBase, such as: |
|
1764 FullName(), Drive(), Path(), DriveAndPath(), Name(), Ext() and NameAndExt() |
|
1765 may be used to retrieve path components. |
|
1766 |
|
1767 There are a number of restrictions to valid path components, which are |
|
1768 described in guide documentation. |
|
1769 */ |
|
1770 { |
|
1771 public: |
|
1772 IMPORT_C TParse(); |
|
1773 IMPORT_C TInt Set(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault); |
|
1774 IMPORT_C TInt SetNoWild(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault); |
|
1775 protected: |
|
1776 IMPORT_C TDes& NameBuf(); |
|
1777 IMPORT_C const TDesC& NameBufC() const; |
|
1778 private: |
|
1779 TFileName iNameBuf; |
|
1780 }; |
|
1781 |
|
1782 |
|
1783 |
|
1784 |
|
1785 class CDir : public CBase |
|
1786 /** |
|
1787 @publishedAll |
|
1788 @released |
|
1789 |
|
1790 Array of directory entries that has been read into memory from the file system. |
|
1791 |
|
1792 It can be read and sorted by user programs, but cannot be created by them. |
|
1793 */ |
|
1794 { |
|
1795 public: |
|
1796 IMPORT_C virtual ~CDir(); |
|
1797 IMPORT_C TInt Count() const; |
|
1798 IMPORT_C const TEntry& operator[](TInt anIndex) const; |
|
1799 IMPORT_C TInt Sort(TUint aEntrySortKey); |
|
1800 protected: |
|
1801 IMPORT_C CDir(); |
|
1802 IMPORT_C static CDir* NewL(); |
|
1803 IMPORT_C void AddL(const TEntry& anEntry); |
|
1804 IMPORT_C void ExtractL(TBool aRemove,CDir*& aDir); |
|
1805 IMPORT_C void Compress(); |
|
1806 protected: |
|
1807 CArrayPakFlat<TEntry>* iArray; |
|
1808 friend class RFs; |
|
1809 friend class TOpenFileScan; |
|
1810 }; |
|
1811 |
|
1812 |
|
1813 #if defined SYMBIAN_PRIVATE_EFSRV |
|
1814 #define EFSRV_EXPORT_C |
|
1815 #define EFSRV_IMPORT_C |
|
1816 #else |
|
1817 #define EFSRV_EXPORT_C EXPORT_C |
|
1818 #define EFSRV_IMPORT_C IMPORT_C |
|
1819 #endif |
|
1820 |
|
1821 |
|
1822 class RFs : public RSessionBase |
|
1823 /** |
|
1824 @publishedAll |
|
1825 @released |
|
1826 |
|
1827 A handle to a file server session. |
|
1828 |
|
1829 A program or thread may have arbitrarily many sessions open simultaneously. |
|
1830 |
|
1831 Use this class for all file system manipulation, including: |
|
1832 |
|
1833 1. adding, removing, moving and renaming files and directories |
|
1834 |
|
1835 2. inspecting and changing file attributes and directory entry details. |
|
1836 These include the time and date when the file or directory was last |
|
1837 written to, its size and various attribute flags such as read-only, |
|
1838 hidden, archive or system. |
|
1839 |
|
1840 3. finding a file’s real name; if the file system on which it is stored |
|
1841 has to "mangle" the name into a shorter format |
|
1842 |
|
1843 4. getting directory listings |
|
1844 |
|
1845 5. maintaining a default path; unlike some other systems, there is a single |
|
1846 system default path, rather than one for each drive: the default path |
|
1847 consists of a drive and a path specification. |
|
1848 |
|
1849 6. performing context-sensitive parses using TParse objects, and |
|
1850 the session path |
|
1851 |
|
1852 7. obtaining information on drives and volumes |
|
1853 |
|
1854 8. formatting and labelling volumes |
|
1855 |
|
1856 9. obtaining a list of valid drives |
|
1857 |
|
1858 10. emulating the DOS subst command, which allows any directory to appear |
|
1859 as if it were a separate drive |
|
1860 |
|
1861 11. requesting notification of when significant change occurs. |
|
1862 This can be used for programs which maintain file lists, but must |
|
1863 update those lists when change occurs. |
|
1864 |
|
1865 12. finding the version number of the file server |
|
1866 |
|
1867 13. resource counting to ensure that all resources are closed when |
|
1868 the session terminates. |
|
1869 |
|
1870 This class is not intended for user derivation. |
|
1871 |
|
1872 The following restrictions apply when a path is specified: |
|
1873 |
|
1874 1. its total length must not exceed 256 characters |
|
1875 |
|
1876 2. wildcards cannot be used in the drive or in any directory name, |
|
1877 although they may be allowed in the filename and extension. |
|
1878 |
|
1879 3. double backslashes are not allowed in the path. |
|
1880 |
|
1881 4. the following characters must not be included anywhere in the path: < > " / | |
|
1882 |
|
1883 5. a colon may only be included between the drive and path |
|
1884 |
|
1885 6. no directory name or filename plus extension may consist solely |
|
1886 of space characters, or of a single or double dot. |
|
1887 |
|
1888 7. spaces between the drive, if specified, and the first directory in |
|
1889 the path are illegal, although there may be spaces between other |
|
1890 path components, for instance between directories. |
|
1891 */ |
|
1892 { |
|
1893 public: |
|
1894 EFSRV_IMPORT_C TInt Connect(TInt aMessageSlots=KFileServerDefaultMessageSlots); |
|
1895 EFSRV_IMPORT_C void Close(); |
|
1896 EFSRV_IMPORT_C TVersion Version() const; |
|
1897 EFSRV_IMPORT_C TInt AddFileSystem(const TDesC& aFileName) const; |
|
1898 EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const; |
|
1899 EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive, TBool aIsSync) const; |
|
1900 EFSRV_IMPORT_C TInt MountFileSystemAndScan(const TDesC& aFileSystemName,TInt aDrive,TBool& aIsMountSuccess) const; |
|
1901 EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive); |
|
1902 EFSRV_IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive, TBool aIsSync); |
|
1903 EFSRV_IMPORT_C TInt MountFileSystemAndScan(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive,TBool& aIsMountSuccess) const; |
|
1904 EFSRV_IMPORT_C TInt DismountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const; |
|
1905 EFSRV_IMPORT_C TInt RemoveFileSystem(const TDesC& aFileSystemName) const; |
|
1906 EFSRV_IMPORT_C TInt FileSystemName(TDes& aName,TInt aDrive) const; |
|
1907 EFSRV_IMPORT_C TInt AddExtension(const TDesC& aFileName); |
|
1908 EFSRV_IMPORT_C TInt MountExtension(const TDesC& aExtensionName,TInt aDrive); |
|
1909 EFSRV_IMPORT_C TInt DismountExtension(const TDesC& aExtensionName,TInt aDrive); |
|
1910 EFSRV_IMPORT_C TInt RemoveExtension(const TDesC& aExtensionName); |
|
1911 EFSRV_IMPORT_C TInt ExtensionName(TDes& aExtensionName,TInt aDrive,TInt aPos); |
|
1912 EFSRV_IMPORT_C TInt RemountDrive(TInt aDrive,const TDesC8* aMountInfo=NULL,TUint aFlags=0); |
|
1913 EFSRV_IMPORT_C void NotifyChange(TNotifyType aType,TRequestStatus& aStat); |
|
1914 EFSRV_IMPORT_C void NotifyChange(TNotifyType aType,TRequestStatus& aStat,const TDesC& aPathName); |
|
1915 EFSRV_IMPORT_C void NotifyChangeCancel(); |
|
1916 EFSRV_IMPORT_C void NotifyChangeCancel(TRequestStatus& aStat); |
|
1917 EFSRV_IMPORT_C void NotifyDiskSpace(TInt64 aThreshold,TInt aDrive,TRequestStatus& aStat); |
|
1918 EFSRV_IMPORT_C void NotifyDiskSpaceCancel(TRequestStatus& aStat); |
|
1919 EFSRV_IMPORT_C void NotifyDiskSpaceCancel(); |
|
1920 EFSRV_IMPORT_C TInt DriveList(TDriveList& aList) const; |
|
1921 EFSRV_IMPORT_C TInt DriveList(TDriveList& aList, TUint aFlags) const; |
|
1922 EFSRV_IMPORT_C TInt Drive(TDriveInfo& anInfo,TInt aDrive=KDefaultDrive) const; |
|
1923 EFSRV_IMPORT_C TInt Volume(TVolumeInfo& aVol,TInt aDrive=KDefaultDrive) const; |
|
1924 EFSRV_IMPORT_C void Volume(TVolumeInfo& aVol,TInt aDrive, TRequestStatus& aStat) const; |
|
1925 EFSRV_IMPORT_C TInt SetVolumeLabel(const TDesC& aName,TInt aDrive=KDefaultDrive); |
|
1926 EFSRV_IMPORT_C TInt Subst(TDes& aPath,TInt aDrive=KDefaultDrive) const; |
|
1927 EFSRV_IMPORT_C TInt SetSubst(const TDesC& aPath,TInt aDrive=KDefaultDrive); |
|
1928 EFSRV_IMPORT_C TInt RealName(const TDesC& aName,TDes& aResult) const; |
|
1929 EFSRV_IMPORT_C TInt GetMediaSerialNumber(TMediaSerialNumber& aSerialNum, TInt aDrive); |
|
1930 EFSRV_IMPORT_C TInt SessionPath(TDes& aPath) const; |
|
1931 EFSRV_IMPORT_C TInt SetSessionPath(const TDesC& aPath); |
|
1932 EFSRV_IMPORT_C TInt Parse(const TDesC& aName,TParse& aParse) const; |
|
1933 EFSRV_IMPORT_C TInt Parse(const TDesC& aName,const TDesC& aRelated,TParse& aParse) const; |
|
1934 EFSRV_IMPORT_C TInt MkDir(const TDesC& aPath); |
|
1935 EFSRV_IMPORT_C TInt MkDirAll(const TDesC& aPath); |
|
1936 EFSRV_IMPORT_C TInt RmDir(const TDesC& aPath); |
|
1937 EFSRV_IMPORT_C TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList) const; |
|
1938 EFSRV_IMPORT_C TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList) const; |
|
1939 EFSRV_IMPORT_C TInt GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList) const; |
|
1940 EFSRV_IMPORT_C TInt Delete(const TDesC& aName); |
|
1941 EFSRV_IMPORT_C TInt Rename(const TDesC& anOldName,const TDesC& aNewName); |
|
1942 EFSRV_IMPORT_C TInt Replace(const TDesC& anOldName,const TDesC& aNewName); |
|
1943 EFSRV_IMPORT_C TInt Att(const TDesC& aName,TUint& aAttValue) const; |
|
1944 EFSRV_IMPORT_C TInt SetAtt(const TDesC& aName,TUint aSetAttMask,TUint aClearAttMask); |
|
1945 EFSRV_IMPORT_C TInt Modified(const TDesC& aName,TTime& aTime) const; |
|
1946 EFSRV_IMPORT_C TInt SetModified(const TDesC& aName,const TTime& aTime); |
|
1947 EFSRV_IMPORT_C TInt Entry(const TDesC& aName,TEntry& anEntry) const; |
|
1948 EFSRV_IMPORT_C TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask); |
|
1949 private: |
|
1950 EFSRV_IMPORT_C TInt ReadFileSection_RESERVED(const TDesC& aName,TInt aPos,TDes8& aDes,TInt aLength) const; |
|
1951 public: |
|
1952 EFSRV_IMPORT_C static TBool IsValidDrive(TInt aDrive); |
|
1953 EFSRV_IMPORT_C static TInt CharToDrive(TChar aChar,TInt& aDrive); |
|
1954 EFSRV_IMPORT_C static TInt DriveToChar(TInt aDrive,TChar& aChar); |
|
1955 EFSRV_IMPORT_C static TBool IsRomAddress(TAny* aAny); |
|
1956 EFSRV_IMPORT_C static TDriveNumber GetSystemDrive(); |
|
1957 EFSRV_IMPORT_C static TChar GetSystemDriveChar(); |
|
1958 EFSRV_IMPORT_C TInt SetSystemDrive(TDriveNumber aSystemDrive); |
|
1959 EFSRV_IMPORT_C void ResourceCountMarkStart() const; |
|
1960 EFSRV_IMPORT_C void ResourceCountMarkEnd() const; |
|
1961 EFSRV_IMPORT_C TInt ResourceCount() const; |
|
1962 EFSRV_IMPORT_C TInt IsFileOpen(const TDesC& aFile,TBool& anAnswer) const; |
|
1963 EFSRV_IMPORT_C TInt CheckDisk(const TDesC& aDrive) const; |
|
1964 EFSRV_IMPORT_C TInt ScanDrive(const TDesC& aDrive) const; |
|
1965 EFSRV_IMPORT_C TInt GetShortName(const TDesC& aLongName,TDes& aShortName) const; |
|
1966 EFSRV_IMPORT_C TInt GetLongName(const TDesC& aShortName,TDes& aLongName) const; |
|
1967 EFSRV_IMPORT_C TBool GetNotifyUser(); |
|
1968 EFSRV_IMPORT_C void SetNotifyUser(TBool aValue); |
|
1969 EFSRV_IMPORT_C TUint8* IsFileInRom(const TDesC& aFileName) const; |
|
1970 EFSRV_IMPORT_C TBool IsValidName(const TDesC& anEntryName) const; |
|
1971 EFSRV_IMPORT_C TBool IsValidName(const TDesC& aFileName,TText& aBadChar) const; |
|
1972 EFSRV_IMPORT_C TInt GetDriveName(TInt aDrive,TDes& aDriveName) const; |
|
1973 EFSRV_IMPORT_C TInt SetDriveName(TInt aDrive,const TDesC& aDriveName); |
|
1974 EFSRV_IMPORT_C TInt LoaderHeapFunction(TInt aFunction, TAny *aArg1=NULL, TAny *aArg2=NULL); |
|
1975 IMPORT_C TInt SetErrorCondition(TInt anError,TInt aCount=0); |
|
1976 EFSRV_IMPORT_C TInt SetDebugRegister(TInt aVal); |
|
1977 EFSRV_IMPORT_C TInt SetAllocFailure(TInt aAllocNum); |
|
1978 EFSRV_IMPORT_C void DebugNotify(TInt aDrive,TUint aNotifyType,TRequestStatus& aStat); |
|
1979 EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand); |
|
1980 EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1); |
|
1981 EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1,TDes8& aParam2); |
|
1982 EFSRV_IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TAny* aParam1,TAny* aParam2); |
|
1983 EFSRV_IMPORT_C TInt LockDrive(TInt aDrv, const TMediaPassword &aOld, const TMediaPassword &aNew, TBool aStr); |
|
1984 EFSRV_IMPORT_C TInt UnlockDrive(TInt aDrv, const TMediaPassword &Pswd, TBool aStr); |
|
1985 EFSRV_IMPORT_C TInt ClearPassword(TInt aDrv, const TMediaPassword &aPswd); |
|
1986 EFSRV_IMPORT_C TInt ErasePassword(TInt aDrv); |
|
1987 EFSRV_IMPORT_C TInt SetSessionToPrivate(TInt aDrive); |
|
1988 EFSRV_IMPORT_C TInt PrivatePath(TDes& aPath); |
|
1989 EFSRV_IMPORT_C TInt CreatePrivatePath(TInt aDrive); |
|
1990 EFSRV_IMPORT_C void StartupInitComplete(TRequestStatus& aStat); |
|
1991 EFSRV_IMPORT_C TInt SetLocalDriveMapping(const TDesC8& aMapping); |
|
1992 |
|
1993 EFSRV_IMPORT_C TInt FinaliseDrives(); |
|
1994 |
|
1995 /** specifies drive finalisation modes */ |
|
1996 enum TFinaliseDrvMode |
|
1997 { |
|
1998 EFinal_RW, ///< after successful finalisation the drive remains writable and will become "not finalised" after the first write operation. |
|
1999 EFinal_RO, ///< after successful finalisation the drive becomes read-only |
|
2000 EForceUnfinalise///< @internalComponent mark the drive as "not finalised" can result in KErrAbort if the dive is in inconsistent state. |
|
2001 }; |
|
2002 |
|
2003 EFSRV_IMPORT_C TInt FinaliseDrive(TInt aDriveNo, TFinaliseDrvMode aMode) const; |
|
2004 |
|
2005 EFSRV_IMPORT_C TInt SwapFileSystem(const TDesC& aOldFileSystemName,const TDesC& aNewFileSystemName,TInt aDrive) const; |
|
2006 EFSRV_IMPORT_C TInt ReserveDriveSpace(TInt aDriveNo, TInt aSpace); |
|
2007 EFSRV_IMPORT_C TInt GetReserveAccess(TInt aDriveNo); |
|
2008 EFSRV_IMPORT_C TInt ReleaseReserveAccess(TInt aDriveNo); |
|
2009 |
|
2010 EFSRV_IMPORT_C TInt AddPlugin(const TDesC& aFileName) const; |
|
2011 EFSRV_IMPORT_C TInt RemovePlugin(const TDesC& aPluginName) const; |
|
2012 EFSRV_IMPORT_C TInt PluginName(TDes& aPluginName,TInt aDrive,TInt aPos); |
|
2013 |
|
2014 EFSRV_IMPORT_C TInt MountPlugin(const TDesC& aPluginName) const; |
|
2015 EFSRV_IMPORT_C TInt MountPlugin(const TDesC& aPluginName,TInt aDrive) const; |
|
2016 EFSRV_IMPORT_C TInt MountPlugin(const TDesC& aPluginName,TInt aDrive, TInt aPos) const; |
|
2017 |
|
2018 EFSRV_IMPORT_C TInt DismountPlugin(const TDesC& aPluginName) const; |
|
2019 EFSRV_IMPORT_C TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive) const; |
|
2020 EFSRV_IMPORT_C TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive,TInt aPos) const; |
|
2021 |
|
2022 EFSRV_IMPORT_C void NotifyDismount(TInt aDrive, TRequestStatus& aStat, TNotifyDismountMode aMode=EFsDismountRegisterClient) const; |
|
2023 EFSRV_IMPORT_C void NotifyDismountCancel(TRequestStatus& aStat) const; |
|
2024 EFSRV_IMPORT_C void NotifyDismountCancel() const; |
|
2025 EFSRV_IMPORT_C TInt AllowDismount(TInt aDrive) const; |
|
2026 EFSRV_IMPORT_C TInt SetStartupConfiguration(TInt aCommand,TAny* aParam1,TAny* aParam2) const; |
|
2027 EFSRV_IMPORT_C TInt AddCompositeMount(const TDesC& aFileSystemName,TInt aLocalDriveToMount,TInt aCompositeDrive, TBool aSync) const; |
|
2028 EFSRV_IMPORT_C TInt SetNotifyChange(TBool aNotifyChange); |
|
2029 EFSRV_IMPORT_C TInt QueryVolumeInfoExt(TInt aDrive, TQueryVolumeInfoExtCmd aCommand, TDes8& aInfo) const; |
|
2030 EFSRV_IMPORT_C TInt VolumeIOParam(TInt aDriveNo, TVolumeIOParamInfo& aParamInfo) const; |
|
2031 EFSRV_IMPORT_C TInt FileSystemSubType(TInt aDriveNo, TDes& aName) const; |
|
2032 EFSRV_IMPORT_C TInt InitialisePropertiesFile(const TPtrC8& aPtr) const; |
|
2033 |
|
2034 IMPORT_C TInt AddProxyDrive(const TDesC& aFileName); |
|
2035 IMPORT_C TInt RemoveProxyDrive(const TDesC& aDriveName); |
|
2036 |
|
2037 template <class T0,class T1> inline TInt MountProxyDrive(const TUint aDrive, const TDesC& aName, T0 a0, T1 a1) |
|
2038 { return(DoMountProxyDrive(TIpcArgs(aDrive, &aName, a0, a1))); }; |
|
2039 IMPORT_C TInt DismountProxyDrive(const TUint aDrive); |
|
2040 |
|
2041 TInt Unclamp(const RFileClamp& aHandle); |
|
2042 |
|
2043 EFSRV_IMPORT_C TInt ReadFileSection(const TDesC& aName,TInt64 aPos,TDes8& aDes,TInt aLength) const; |
|
2044 |
|
2045 /** |
|
2046 This class is used to for returning meaningful error code values to users of RFs::IsValidName(const TDesC& ,TNameValidParam& ) |
|
2047 @see TError |
|
2048 */ |
|
2049 class TNameValidParam |
|
2050 { |
|
2051 public: |
|
2052 /** Initialises the members of the class. By default iUseSessionPath is set to EFalse, however one could set it to ETrue.*/ |
|
2053 inline TNameValidParam(TBool aUseSessionPath = EFalse); |
|
2054 |
|
2055 /** possible error codes */ |
|
2056 enum TError |
|
2057 { |
|
2058 ErrNone, ///< no error. |
|
2059 ErrBadCharacter, ///< aName contains a bad character; and its position is in iInvalidCharPos. |
|
2060 ErrBadName, ///< aName isn't a valid file or directory name. |
|
2061 ErrNameTooLong ///< aName length or aName + session path length (see iUseSessionPath) is longer than 256 characters. |
|
2062 }; |
|
2063 |
|
2064 inline TError ErrorCode() const; |
|
2065 inline void UseSessionPath(TBool aUseSessionPath); |
|
2066 inline TUint InvalidCharPos() const; |
|
2067 friend class TFsIsValidName; |
|
2068 private: |
|
2069 TError iError; ///< the reason why aName is invalid, see TError |
|
2070 TBool iUseSessionPath; ///< if ETrue, and if aName isn't fully specified, missing parts will be taken from the session path |
|
2071 TUint iInvalidCharPos; ///< may contain invalid character position if error is ErrBadCharacter,else 0. |
|
2072 }; |
|
2073 EFSRV_IMPORT_C TBool IsValidName(const TDesC& aName, TNameValidParam& aParam ); |
|
2074 |
|
2075 /** Special enumerator values for the SupportedFileSystemName() API */ |
|
2076 enum |
|
2077 { |
|
2078 KRootFileSystem = 0x00800000, ///< specifies "root" file system. The result will be the same as for FileSystemName() API call |
|
2079 KFirstChildFileSystem = 0 ///< specifies the first child file system number, the second will be KFirstChildFileSystem+1 etc. |
|
2080 }; |
|
2081 |
|
2082 EFSRV_IMPORT_C TInt SupportedFileSystemName(TDes& aName, TInt aDrive, TInt aFsEnumerator) const; |
|
2083 |
|
2084 protected: |
|
2085 TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const; |
|
2086 |
|
2087 private: |
|
2088 void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList,RDir& aDir) const; |
|
2089 void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const; |
|
2090 void GetDirL(const TDesC& aMatchName,const TUidType& aUidType,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const; |
|
2091 void DoGetDirL(TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const; |
|
2092 TInt GetOpenFileList(TInt& aSessionNum,TInt& aLocalPos,TThreadId& aThreadId,TEntryArray& anArray) const; |
|
2093 |
|
2094 IMPORT_C TInt DoMountProxyDrive(const TIpcArgs& ipcArgs); |
|
2095 |
|
2096 friend class TOpenFileScan; |
|
2097 friend class RFsPlugin; |
|
2098 }; |
|
2099 |
|
2100 |
|
2101 //------------------------------------------------------------------------------------------------------------------- |
|
2102 |
|
2103 /** |
|
2104 |
|
2105 Base class for volume formatting parameters. This class package buffer, TVolFormatParamBuf or |
|
2106 packaged buffer of the derived class can be passed to the RFormat::Open() in order to provide |
|
2107 file system-specific formatting parameters. |
|
2108 Each file system that supports such formatting parameters shall have this class specialisation (e.g. TVolFormatParam_FAT) |
|
2109 All classes, derived from this one must have the same size as the base class. |
|
2110 In order to use formatting parameters the format mode shall have ESpecialFormat bit flag set. |
|
2111 |
|
2112 |
|
2113 @see RFormat::Open(RFs&,const TDesC&,TUint,TInt& ,const TDesC8& anInfo); |
|
2114 @see TVolFormatParamBuf |
|
2115 |
|
2116 @publishedAll |
|
2117 @released |
|
2118 */ |
|
2119 class TVolFormatParam |
|
2120 { |
|
2121 public: |
|
2122 inline TVolFormatParam(); |
|
2123 inline void Init(); |
|
2124 |
|
2125 inline void SetFileSystemName(const TDesC& aFsName); |
|
2126 |
|
2127 static inline TUint32 CalcFSNameHash(const TDesC& aFsName); |
|
2128 inline TUint32 FSNameHash() const; |
|
2129 |
|
2130 inline TBool SomeParamsSet() const; |
|
2131 |
|
2132 |
|
2133 protected: |
|
2134 |
|
2135 |
|
2136 enum {KMaxDataSlots = 64}; ///< the size of data array iData |
|
2137 |
|
2138 inline void SetVal(TUint aIndex, TUint32 aVal); |
|
2139 inline TUint32 GetVal(TUint aIndex) const; |
|
2140 |
|
2141 |
|
2142 public: |
|
2143 enum {KUId = 0x820116A2}; ///< this value shell be in iUid field to identify this class object |
|
2144 |
|
2145 /** |
|
2146 This class tree UID. Used to distinguish the object of this class from TLDFormatInfo and other possible data structures. |
|
2147 For this and derived classes this field must be KUId. This field offset in the class must be 0 |
|
2148 */ |
|
2149 const TUint32 iUId; |
|
2150 |
|
2151 private: |
|
2152 TUint32 iFSysNameHash; ///< Up-cased file system name hash (crc32) used to designate the file system. 0 means "not set" |
|
2153 TBool iParamsSet : 1; ///< ETrue if any parameter was set (SetVal() called). Gets reset to EFalse by Init() |
|
2154 TUint32 iData[KMaxDataSlots]; ///< used as a pool for various data. The derived classes are free to use it by SetVal()/GetVal() |
|
2155 }; |
|
2156 |
|
2157 __ASSERT_COMPILE(_FOFF(TVolFormatParam, iUId) == 0); |
|
2158 __ASSERT_COMPILE(sizeof(TVolFormatParam) != sizeof(TLDFormatInfo)); |
|
2159 |
|
2160 |
|
2161 /** package buffer for the objects of class TVolFormatParamBuf */ |
|
2162 typedef TPckgBuf<TVolFormatParam> TVolFormatParamBuf; |
|
2163 |
|
2164 |
|
2165 |
|
2166 |
|
2167 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
2168 /** |
|
2169 @publishedAll |
|
2170 @released |
|
2171 |
|
2172 Creates and opens a file, and performs all operations on a single open file. |
|
2173 |
|
2174 These include: |
|
2175 |
|
2176 - reading from and writing to the file |
|
2177 |
|
2178 - seeking to a position within the file |
|
2179 |
|
2180 - locking and unlocking within the file |
|
2181 |
|
2182 - setting file attributes |
|
2183 |
|
2184 Before using any of these services, a connection to a file server session must |
|
2185 have been made, and the file must be open. |
|
2186 |
|
2187 Opening Files: |
|
2188 |
|
2189 - use Open() to open an existing file for reading or writing; an error is |
|
2190 returned if it does not already exist. |
|
2191 To open an existing file for reading only, use Open() with an access mode of |
|
2192 EFileRead, and a share mode of EFileShareReadersOnly. |
|
2193 |
|
2194 - use Create() to create and open a new file for writing; an error is returned |
|
2195 if it already exists. |
|
2196 |
|
2197 - use Replace() to open a file for writing, replacing any existing file of |
|
2198 the same name if one exists, or creating a new file if one does not exist. |
|
2199 Note that if a file exists, its length is reset to zero. |
|
2200 |
|
2201 - use Temp() to create and open a temporary file with a unique name, |
|
2202 for writing and reading. |
|
2203 |
|
2204 When opening a file, you must specify the file server session to use for |
|
2205 operations with that file. If you do not close the file explicitly, it is |
|
2206 closed when the server session associated with it is closed. |
|
2207 |
|
2208 Reading and Writing: |
|
2209 |
|
2210 There are several variants of both Read() and Write(). |
|
2211 The basic Read(TDes8& aDes) and Write(const TDesC8& aDes) are supplemented |
|
2212 by variants allowing the descriptor length to be overridden, or the seek |
|
2213 position of the first byte to be specified, or asynchronous completion, |
|
2214 or any combination. |
|
2215 |
|
2216 Reading transfers data from a file to a descriptor, and writing transfers |
|
2217 data from a descriptor to a file. In all cases, the file data is treated |
|
2218 as binary and byte descriptors are used (TDes8, TDesC8). |
|
2219 |
|
2220 @see TDes8 |
|
2221 @see TDesC8 |
|
2222 */ |
|
2223 #else |
|
2224 /** |
|
2225 @publishedAll |
|
2226 @released |
|
2227 |
|
2228 Creates and opens a file, and performs all operations on a single open file. |
|
2229 |
|
2230 These include: |
|
2231 |
|
2232 - reading from and writing to the file |
|
2233 |
|
2234 - seeking to a position within the file |
|
2235 |
|
2236 - locking and unlocking within the file |
|
2237 |
|
2238 - setting file attributes |
|
2239 |
|
2240 Before using any of these services, a connection to a file server session must |
|
2241 have been made, and the file must be open. |
|
2242 |
|
2243 Opening Files: |
|
2244 |
|
2245 - use Open() to open an existing file for reading or writing; an error is |
|
2246 returned if it does not already exist. |
|
2247 To open an existing file for reading only, use Open() with an access mode of |
|
2248 EFileRead, and a share mode of EFileShareReadersOnly. |
|
2249 |
|
2250 - use Create() to create and open a new file for writing; an error is returned |
|
2251 if it already exists. |
|
2252 |
|
2253 - use Replace() to open a file for writing, replacing any existing file of |
|
2254 the same name if one exists, or creating a new file if one does not exist. |
|
2255 Note that if a file exists, its length is reset to zero. |
|
2256 |
|
2257 - use Temp() to create and open a temporary file with a unique name, |
|
2258 for writing and reading. |
|
2259 |
|
2260 When opening a file, you must specify the file server session to use for |
|
2261 operations with that file. If you do not close the file explicitly, it is |
|
2262 closed when the server session associated with it is closed. |
|
2263 |
|
2264 Reading and Writing: |
|
2265 |
|
2266 There are several variants of both Read() and Write(). |
|
2267 The basic Read(TDes8& aDes) and Write(const TDesC8& aDes) are supplemented |
|
2268 by variants allowing the descriptor length to be overridden, or the seek |
|
2269 position of the first byte to be specified, or asynchronous completion, |
|
2270 or any combination. |
|
2271 |
|
2272 Reading transfers data from a file to a descriptor, and writing transfers |
|
2273 data from a descriptor to a file. In all cases, the file data is treated |
|
2274 as binary and byte descriptors are used (TDes8, TDesC8). |
|
2275 |
|
2276 RFile class supports operations on files of size less than or equal to 2GB - 1. |
|
2277 If the file size is greater than 2GB - 1 (large file), use of class RFile64 is |
|
2278 recommended for following operations: |
|
2279 1. Opening a large file |
|
2280 2. Creating a file which can grow beyond 2GB - 1 by size |
|
2281 3. Creating a temporary file which can grow beyond 2GB - 1 by size |
|
2282 4. Replacing an existing file after which it can grow beyond 2GB - 1 by size |
|
2283 5. Adopting a large file handle from client |
|
2284 6. Adopting a large file handle from server |
|
2285 7. Adopting a large file handle from another process |
|
2286 8. Read from a position greater than 2GB - 1 |
|
2287 9. Writing to a file by which the size can grow beyond 2GB - 1 |
|
2288 10. Seek to a position greater than 2GB - 1 |
|
2289 11. Setting a size greater than 2GB - 1 |
|
2290 12. Querying the file size (greater than 2GB - 1) |
|
2291 13. Locking and unlocking a position and length that is beyond 2GB - 1 |
|
2292 |
|
2293 @see TDes8 |
|
2294 @see TDesC8 |
|
2295 |
|
2296 @see RFile64 |
|
2297 |
|
2298 */ |
|
2299 |
|
2300 #endif |
|
2301 |
|
2302 |
|
2303 class RFile : public RSubSessionBase |
|
2304 { |
|
2305 public: |
|
2306 EFSRV_IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode); |
|
2307 EFSRV_IMPORT_C void Close(); |
|
2308 EFSRV_IMPORT_C TInt Create(RFs& aFs,const TDesC& aName,TUint aFileMode); |
|
2309 EFSRV_IMPORT_C TInt Replace(RFs& aFs,const TDesC& aName,TUint aFileMode); |
|
2310 EFSRV_IMPORT_C TInt Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode); |
|
2311 EFSRV_IMPORT_C TInt Read(TDes8& aDes) const; |
|
2312 EFSRV_IMPORT_C void Read(TDes8& aDes,TRequestStatus& aStatus) const; |
|
2313 EFSRV_IMPORT_C TInt Read(TDes8& aDes,TInt aLength) const; |
|
2314 EFSRV_IMPORT_C void Read(TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const; |
|
2315 EFSRV_IMPORT_C TInt Read(TInt aPos,TDes8& aDes) const; |
|
2316 EFSRV_IMPORT_C void Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const; |
|
2317 EFSRV_IMPORT_C TInt Read(TInt aPos,TDes8& aDes,TInt aLength) const; |
|
2318 EFSRV_IMPORT_C void Read(TInt aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const; |
|
2319 EFSRV_IMPORT_C void ReadCancel(TRequestStatus& aStatus) const; |
|
2320 EFSRV_IMPORT_C void ReadCancel() const; |
|
2321 EFSRV_IMPORT_C TInt Write(const TDesC8& aDes); |
|
2322 EFSRV_IMPORT_C void Write(const TDesC8& aDes,TRequestStatus& aStatus); |
|
2323 EFSRV_IMPORT_C TInt Write(const TDesC8& aDes,TInt aLength); |
|
2324 EFSRV_IMPORT_C void Write(const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus); |
|
2325 EFSRV_IMPORT_C TInt Write(TInt aPos,const TDesC8& aDes); |
|
2326 EFSRV_IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus); |
|
2327 EFSRV_IMPORT_C TInt Write(TInt aPos,const TDesC8& aDes,TInt aLength); |
|
2328 EFSRV_IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus); |
|
2329 EFSRV_IMPORT_C TInt Lock(TInt aPos,TInt aLength) const; |
|
2330 EFSRV_IMPORT_C TInt UnLock(TInt aPos,TInt aLength) const; |
|
2331 EFSRV_IMPORT_C TInt Seek(TSeek aMode,TInt& aPos) const; |
|
2332 EFSRV_IMPORT_C TInt Flush(); |
|
2333 EFSRV_IMPORT_C void Flush(TRequestStatus& aStatus); |
|
2334 EFSRV_IMPORT_C TInt Size(TInt& aSize) const; |
|
2335 EFSRV_IMPORT_C TInt SetSize(TInt aSize); |
|
2336 EFSRV_IMPORT_C TInt Att(TUint& aAttValue) const; |
|
2337 EFSRV_IMPORT_C TInt SetAtt(TUint aSetAttMask,TUint aClearAttMask); |
|
2338 EFSRV_IMPORT_C TInt Modified(TTime& aTime) const; |
|
2339 EFSRV_IMPORT_C TInt SetModified(const TTime& aTime); |
|
2340 EFSRV_IMPORT_C TInt Set(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask); |
|
2341 EFSRV_IMPORT_C TInt ChangeMode(TFileMode aNewMode); |
|
2342 EFSRV_IMPORT_C TInt Rename(const TDesC& aNewName); |
|
2343 EFSRV_IMPORT_C TInt Drive(TInt &aDriveNumber, TDriveInfo &aDriveInfo) const; |
|
2344 EFSRV_IMPORT_C TInt Adopt(RFs& aFs, TInt aHandle); |
|
2345 EFSRV_IMPORT_C TInt AdoptFromClient(const RMessage2& aMsg, TInt aFsHandleIndex, TInt aFileHandleIndex); |
|
2346 EFSRV_IMPORT_C TInt AdoptFromServer(TInt aFsHandle, TInt aFileHandle); |
|
2347 EFSRV_IMPORT_C TInt AdoptFromCreator(TInt aFsIndex, TInt aFileHandleIndex); |
|
2348 EFSRV_IMPORT_C TInt Name(TDes& aName) const; |
|
2349 EFSRV_IMPORT_C TInt TransferToServer(TIpcArgs& aIpcArgs, TInt aFsHandleIndex, TInt aFileHandleIndex) const; |
|
2350 EFSRV_IMPORT_C TInt TransferToClient(const RMessage2& aMsg, TInt aFileHandleIndex) const; |
|
2351 EFSRV_IMPORT_C TInt TransferToProcess(RProcess& aProcess, TInt aFsHandleIndex, TInt aFileHandleIndex) const; |
|
2352 EFSRV_IMPORT_C TInt Duplicate(const RFile& aFile, TOwnerType aType=EOwnerProcess); |
|
2353 EFSRV_IMPORT_C TInt FullName(TDes& aName) const; |
|
2354 EFSRV_IMPORT_C TInt BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos=-1, TInt aBlockMapusage=EBlockMapUsagePaging) const; |
|
2355 TInt Clamp(RFileClamp& aHandle); |
|
2356 |
|
2357 protected: |
|
2358 // RSubSessionBase overrides |
|
2359 TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs); |
|
2360 void CloseSubSession(TInt aFunction); |
|
2361 TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const; |
|
2362 |
|
2363 TInt DuplicateHandle(TInt& aSubSessionHandle) const; |
|
2364 |
|
2365 friend class RFilePlugin; |
|
2366 }; |
|
2367 |
|
2368 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
2369 #include <f32file64.h> |
|
2370 #endif |
|
2371 |
|
2372 class RDir : public RSubSessionBase |
|
2373 /** |
|
2374 @publishedAll |
|
2375 @released |
|
2376 |
|
2377 Reads the entries contained in a directory. |
|
2378 |
|
2379 You must first open the directory, specifying an attribute mask which is used |
|
2380 by Read() calls to filter the entry types required. Then, use one of |
|
2381 the Read() functions to read the filtered entries. When the operation |
|
2382 is complete, the directory should be closed using Close() |
|
2383 |
|
2384 There are two types of Read(): one works with a single entry at a time, |
|
2385 requiring programs to iterate through the entries explicitly. |
|
2386 The other works with an entire TEntryArray, allowing multiple entries to be |
|
2387 read in one call. |
|
2388 As well as making application program logic somewhat simpler, this type |
|
2389 uses fewer calls to the server, and is more efficient. |
|
2390 |
|
2391 Each type of Read() can be performed either synchronously or asynchronously. |
|
2392 |
|
2393 It may be more convenient to use RFs::GetDir() than the Read() calls supported |
|
2394 by this class. |
|
2395 RFs::GetDir() has the advantage that it allows a directory’s entries to be |
|
2396 sorted in various ways. |
|
2397 However, it does not provide asynchronous as well as synchronous variants |
|
2398 and does not allow entries to be read individually. |
|
2399 |
|
2400 @see RFs |
|
2401 */ |
|
2402 { |
|
2403 public: |
|
2404 EFSRV_IMPORT_C TInt Open(RFs& aFs,const TDesC& aMatchName,const TUidType& aUidType); |
|
2405 EFSRV_IMPORT_C TInt Open(RFs& aFs,const TDesC& aMatchName,TUint anAttMask); |
|
2406 EFSRV_IMPORT_C void Close(); |
|
2407 EFSRV_IMPORT_C TInt Read(TEntryArray& anArray) const; |
|
2408 EFSRV_IMPORT_C void Read(TEntryArray& anArray,TRequestStatus& aStatus) const; |
|
2409 EFSRV_IMPORT_C TInt Read(TEntry& anEntry) const; |
|
2410 EFSRV_IMPORT_C void Read(TPckg<TEntry>& anEntry,TRequestStatus& aStatus) const; |
|
2411 |
|
2412 private: |
|
2413 // RSubSessionBase overrides |
|
2414 TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const; |
|
2415 |
|
2416 friend class RDirPlugin; |
|
2417 }; |
|
2418 |
|
2419 |
|
2420 class RFormat : public RSubSessionBase |
|
2421 /** |
|
2422 @publishedAll |
|
2423 @released |
|
2424 |
|
2425 Formats a device, one step at a time. |
|
2426 |
|
2427 RFormat must first be opened on a device before formatting each |
|
2428 track using Next(). |
|
2429 |
|
2430 There is also an asynchronous version of Next() which, if encapsulated into |
|
2431 a suitable active object, can be used to implement a |
|
2432 user-interruptible formatting process. |
|
2433 */ |
|
2434 { |
|
2435 public: |
|
2436 IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount); |
|
2437 IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount,const TDesC8& anInfo); |
|
2438 IMPORT_C void Close(); |
|
2439 IMPORT_C TInt Next(TInt& aStep); |
|
2440 IMPORT_C void Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus); |
|
2441 }; |
|
2442 |
|
2443 |
|
2444 |
|
2445 |
|
2446 class RRawDisk : public RSubSessionBase |
|
2447 /** |
|
2448 @publishedAll |
|
2449 @released |
|
2450 |
|
2451 Enables direct disk access. |
|
2452 |
|
2453 No other resources can access the disk while direct access to it is in effect. |
|
2454 |
|
2455 This class is not intended for user derivation. |
|
2456 */ |
|
2457 { |
|
2458 public: |
|
2459 IMPORT_C TInt Open(RFs& aFs,TInt aDrive); |
|
2460 IMPORT_C void Close(); |
|
2461 IMPORT_C TInt Read(TInt64 aPos,TDes8& aDes); |
|
2462 IMPORT_C TInt Write(TInt64 aPos,TDesC8& aDes); |
|
2463 private: |
|
2464 TInt iDrive; |
|
2465 }; |
|
2466 |
|
2467 |
|
2468 |
|
2469 |
|
2470 class CDirStack; |
|
2471 NONSHARABLE_CLASS(CDirScan) : public CBase |
|
2472 /** |
|
2473 @publishedAll |
|
2474 @released |
|
2475 |
|
2476 Scans a directory structure. |
|
2477 |
|
2478 The scan moves from directory to directory through the hierarchy, returning |
|
2479 a list of the entries contained in each. The order in which the directories |
|
2480 are scanned is determined by a sort key which is specified when setting up |
|
2481 the scan. The base directory to be scanned and the entry types of interest |
|
2482 must also be specified before performing the scan. |
|
2483 |
|
2484 This class is not intended for user derivation |
|
2485 */ |
|
2486 { |
|
2487 public: |
|
2488 /** |
|
2489 Defines the scan direction. |
|
2490 */ |
|
2491 enum TScanDirection |
|
2492 { |
|
2493 /** |
|
2494 Scan upwards from the lowest level directory in the hierarchy to |
|
2495 the top level directory. |
|
2496 */ |
|
2497 EScanUpTree, |
|
2498 |
|
2499 /** |
|
2500 Scan downwards from the top level directory in the hierarchy to |
|
2501 the bottom level directory. |
|
2502 */ |
|
2503 EScanDownTree |
|
2504 }; |
|
2505 public: |
|
2506 IMPORT_C static CDirScan* NewL(RFs& aFs); |
|
2507 IMPORT_C static CDirScan* NewLC(RFs& aFs); |
|
2508 IMPORT_C ~CDirScan(); |
|
2509 IMPORT_C void SetScanDataL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortMask,TScanDirection aScanDir=EScanDownTree); |
|
2510 IMPORT_C void NextL(CDir*& aDirEntries); |
|
2511 IMPORT_C TPtrC AbbreviatedPath(); |
|
2512 IMPORT_C TPtrC FullPath(); |
|
2513 protected: |
|
2514 CDirScan(RFs& aFs); |
|
2515 private: |
|
2516 inline RFs& Fs(); |
|
2517 void UpdateAbbreviatedPath(); |
|
2518 void ScanUpTreeL(CDir*& aDirEntries); |
|
2519 void ScanDownTreeL(CDir*& aDirEntries); |
|
2520 void GetDirEntriesL(CDir*& aDirEntries); |
|
2521 private: |
|
2522 RFs* const iFs; |
|
2523 TParse iFullPath; |
|
2524 TPtrC iAbbreviatedPath; |
|
2525 TInt iAbbreviatedPathPos; |
|
2526 TUint iEntryAttMask; |
|
2527 TUint iEntrySortMask; |
|
2528 TBool iScanning; |
|
2529 TScanDirection iScanDir; |
|
2530 CDirStack* iStack; |
|
2531 }; |
|
2532 |
|
2533 |
|
2534 |
|
2535 |
|
2536 enum TFileManError |
|
2537 /** |
|
2538 @publishedAll |
|
2539 @released |
|
2540 |
|
2541 A list of CFileMan error codes. |
|
2542 |
|
2543 @see CFileMan |
|
2544 */ |
|
2545 { |
|
2546 /** |
|
2547 No additional error information is available, either because |
|
2548 the latest CFileMan operation did not return an error, or if it did, |
|
2549 the error was not one for which additional information is available. |
|
2550 */ |
|
2551 ENoExtraInformation, |
|
2552 |
|
2553 |
|
2554 /** |
|
2555 A leave occurred while setting up the initial scan. |
|
2556 |
|
2557 This indicates that the operation did not begin. |
|
2558 |
|
2559 @see CDirScan. |
|
2560 */ |
|
2561 EInitializationFailed, |
|
2562 |
|
2563 |
|
2564 /** |
|
2565 A leave occurred while scanning the next directory in the course of a file |
|
2566 management function. |
|
2567 |
|
2568 This indicates that the operation did begin. |
|
2569 |
|
2570 @see CDirScan. |
|
2571 */ |
|
2572 EScanNextDirectoryFailed, |
|
2573 |
|
2574 |
|
2575 /** |
|
2576 Error occurred when attempting to open the source file for a file copy |
|
2577 or move. |
|
2578 */ |
|
2579 ESrcOpenFailed, |
|
2580 |
|
2581 |
|
2582 /** |
|
2583 Error occurred while attempting to create, or, if overwriting is in effect, |
|
2584 replace the target file for a file copy or move. |
|
2585 */ |
|
2586 ETrgOpenFailed, |
|
2587 |
|
2588 |
|
2589 /** |
|
2590 The operation completed without processing any files because no matching |
|
2591 files were found. |
|
2592 */ |
|
2593 ENoFilesProcessed |
|
2594 }; |
|
2595 |
|
2596 |
|
2597 |
|
2598 |
|
2599 class MFileManObserver |
|
2600 /** |
|
2601 @publishedAll |
|
2602 @released |
|
2603 |
|
2604 Provides notification of the progress of synchronous or asynchronous |
|
2605 file management operations. |
|
2606 |
|
2607 It should be inherited by classes which implement this protocol. |
|
2608 |
|
2609 The enquiry functions provided by CFileBase and CFileMan may be used by |
|
2610 the observer to display information about the progress of the operation |
|
2611 such as error messages, the names of the target and destination files, |
|
2612 and the number of bytes transferred during a copy operation. |
|
2613 Notification may take place before or after an entry has been processed, |
|
2614 or during a file copy or move. |
|
2615 Each notification function returns a value which can be used to enable |
|
2616 the user to control the progress of the operation, for example to cancel |
|
2617 a long-running multiple file copy. |
|
2618 To use this class, pass a pointer to an instance of the class to |
|
2619 the CFileMan constructor, or use SetObserver(), defined in CFileBase. |
|
2620 */ |
|
2621 { |
|
2622 public: |
|
2623 /** |
|
2624 Control for the current CFileMan operation. |
|
2625 */ |
|
2626 enum TControl |
|
2627 { |
|
2628 /** |
|
2629 Proceed with the current or the next entry. |
|
2630 */ |
|
2631 EContinue, |
|
2632 |
|
2633 |
|
2634 /** |
|
2635 Retry processing the previous entry. |
|
2636 */ |
|
2637 ERetry, |
|
2638 |
|
2639 |
|
2640 /** |
|
2641 Abort operation, causes function to return KErrCancel. |
|
2642 */ |
|
2643 EAbort, |
|
2644 |
|
2645 |
|
2646 /** |
|
2647 Cancel processing the current entry. |
|
2648 */ |
|
2649 ECancel |
|
2650 }; |
|
2651 public: |
|
2652 IMPORT_C virtual TControl NotifyFileManStarted(); |
|
2653 IMPORT_C virtual TControl NotifyFileManOperation(); |
|
2654 IMPORT_C virtual TControl NotifyFileManEnded(); |
|
2655 }; |
|
2656 |
|
2657 |
|
2658 |
|
2659 |
|
2660 class CFileBase : public CBase |
|
2661 /** |
|
2662 @publishedAll |
|
2663 @released |
|
2664 |
|
2665 Abstract base class for file management. |
|
2666 |
|
2667 It provides functions to set an observer for the derived class |
|
2668 CFileMan, and to get information about the entry being processed. |
|
2669 |
|
2670 @see CFileMan |
|
2671 */ |
|
2672 { |
|
2673 public: |
|
2674 IMPORT_C void SetObserver(MFileManObserver* anObserver); |
|
2675 public: |
|
2676 IMPORT_C const TEntry& CurrentEntry(); |
|
2677 IMPORT_C TPtrC AbbreviatedPath(); |
|
2678 IMPORT_C TPtrC FullPath(); |
|
2679 IMPORT_C TInt GetLastError(); |
|
2680 IMPORT_C TFileManError GetMoreInfoAboutError(); |
|
2681 protected: |
|
2682 IMPORT_C CFileBase(RFs& anFs); |
|
2683 IMPORT_C void ConstructL(); |
|
2684 IMPORT_C ~CFileBase(); |
|
2685 IMPORT_C void RunL(); |
|
2686 IMPORT_C void RunInSeparateThreadL(TThreadFunction aThreadFunction); |
|
2687 // virtual |
|
2688 /** |
|
2689 Called from RunL to perform tidy up after an operation. |
|
2690 |
|
2691 @see CFileMan |
|
2692 @see CFileBase::RunL |
|
2693 */ |
|
2694 virtual void CompleteOperationL() {}; |
|
2695 |
|
2696 //pure virtual |
|
2697 /** |
|
2698 Called from RunL to perform the requested operation. |
|
2699 |
|
2700 @see CFileMan |
|
2701 @see CFileBase::RunL |
|
2702 */ |
|
2703 virtual void DoOperationL() = 0; |
|
2704 protected: |
|
2705 RFs iFs; |
|
2706 RFs iFsOld; |
|
2707 RThread iFManThread; |
|
2708 RSemaphore iSynchronizer; |
|
2709 CDirScan* iScanner; |
|
2710 CDir* iDirList; |
|
2711 TInt iCurrentEntry; |
|
2712 TUint iMatchEntry; |
|
2713 TUint iSwitches; |
|
2714 TParse iSrcFile; |
|
2715 MFileManObserver* iObserver; |
|
2716 TInt iLastError; |
|
2717 TFileManError iErrorInfo; |
|
2718 TRequestStatus* iStatus; |
|
2719 HBufC* iSessionPath; |
|
2720 TInt iNumberOfFilesProcessed; |
|
2721 |
|
2722 |
|
2723 |
|
2724 |
|
2725 friend void DoFManBaseOperationL(TAny* aPtr); |
|
2726 friend TInt FManBaseThreadFunction(TAny* aPtr); |
|
2727 }; |
|
2728 |
|
2729 |
|
2730 |
|
2731 |
|
2732 NONSHARABLE_CLASS(CFileMan) : public CFileBase |
|
2733 /** |
|
2734 @publishedAll |
|
2735 @released |
|
2736 |
|
2737 Offers file management services which accept the use of wildcards; |
|
2738 synchronous and asynchronous. |
|
2739 |
|
2740 It also provides enquiry functions, which, like those provided by |
|
2741 the base class CFileBase, may be used by an observer class object |
|
2742 to provide the user with information about the progress of the operation. |
|
2743 |
|
2744 All of the file management functions provided by this class accept the use of |
|
2745 wildcards, and may operate either synchronously or asynchronously. |
|
2746 When CFileMan is operating asynchronously, the operation takes place in |
|
2747 a separate thread from the calling code. |
|
2748 |
|
2749 A file notification observer (an instance of a class deriving |
|
2750 from MFileManObserver) may optionally be used by CFileMan when operating |
|
2751 synchronously or asynchronously. If provided, the appropriate notification |
|
2752 function is called before or after each entry has been processed, |
|
2753 or during a file copy or move. |
|
2754 This notification can be used to provide information about the state of |
|
2755 the operation, such as the number of bytes transferred during a |
|
2756 large-scale file copy. It can also be used to allow the user to cancel, |
|
2757 retry or continue processing an entry, or to abort the whole operation. |
|
2758 If such notification is required, specify an object deriving from |
|
2759 MFileManObserver class in the constructor, or call SetObserver(), |
|
2760 defined in the base class, CFileBase. |
|
2761 |
|
2762 All of the file manipulation functions except Rename() may operate recursively, |
|
2763 and all can operate non-recursively. When operating recursively, |
|
2764 these functions will act on all matching files located throughout |
|
2765 the source directory’s hierarchy. When operating non-recursively, |
|
2766 these functions act upon files contained in the single top level source |
|
2767 directory only. Recursion is set or unset using the switch parameter to |
|
2768 these functions. |
|
2769 |
|
2770 This class is not intended for user derivation. |
|
2771 |
|
2772 Note: |
|
2773 |
|
2774 To support wildcard, CFileMan needs to store the entire directory entry |
|
2775 information. Therefore, in a extreme condition, if a directory contains |
|
2776 a huge number of files (e.g. more than 15000 files with 10 characters' long file |
|
2777 names), user may encounter KErrNoMemory errors. Developers who have a need to handle |
|
2778 this rare case should increase the heap size limitation of their applications. |
|
2779 |
|
2780 For more information about heap size configuration, please refer following |
|
2781 section in Symbian Developer Library: |
|
2782 Symbian OS build guide >> Build Tools Reference >> MMP file syntax >> epocheapsize |
|
2783 |
|
2784 @see MFileManObserver |
|
2785 */ |
|
2786 { |
|
2787 public: |
|
2788 /** |
|
2789 An enumeration that identifies CFileMan tasks. This enumeration is used |
|
2790 by CurrentAction() to identify which task currently being carried out. |
|
2791 |
|
2792 @see CFileMan::CurrentAction |
|
2793 */ |
|
2794 enum TAction |
|
2795 { |
|
2796 /** |
|
2797 Inactive |
|
2798 */ |
|
2799 ENone, |
|
2800 |
|
2801 |
|
2802 /** |
|
2803 Setting attributes |
|
2804 */ |
|
2805 EAttribs, |
|
2806 |
|
2807 |
|
2808 /** |
|
2809 Copying files |
|
2810 */ |
|
2811 ECopy, |
|
2812 |
|
2813 |
|
2814 /** |
|
2815 Deleting files |
|
2816 */ |
|
2817 EDelete, |
|
2818 |
|
2819 |
|
2820 /** |
|
2821 Moving files |
|
2822 */ |
|
2823 EMove, |
|
2824 |
|
2825 |
|
2826 /** |
|
2827 Renaming files |
|
2828 */ |
|
2829 ERename, |
|
2830 |
|
2831 |
|
2832 /** |
|
2833 Deleting a directory and all contents |
|
2834 */ |
|
2835 ERmDir, |
|
2836 |
|
2837 |
|
2838 /** |
|
2839 Renaming component to VFAT short name (guaranteed to be unique) |
|
2840 */ |
|
2841 ERenameInvalidEntry, |
|
2842 |
|
2843 /** |
|
2844 Copying file from open file handle |
|
2845 */ |
|
2846 ECopyFromHandle, |
|
2847 }; |
|
2848 |
|
2849 |
|
2850 /** |
|
2851 Overwriting and recursion switch. |
|
2852 |
|
2853 Used in CFileMan functions to set whether operations are applied to |
|
2854 the specified directory and all directories below it, or |
|
2855 the specified directory only. |
|
2856 */ |
|
2857 enum TSwitch |
|
2858 { |
|
2859 /** |
|
2860 Any files in the destination directory that have the same name as |
|
2861 the source files in a rename, move or copy operation, will |
|
2862 be overwritten. |
|
2863 */ |
|
2864 EOverWrite=1, |
|
2865 |
|
2866 |
|
2867 /** |
|
2868 Recursive operation. |
|
2869 */ |
|
2870 ERecurse=2 |
|
2871 }; |
|
2872 public: |
|
2873 IMPORT_C static CFileMan* NewL(RFs& aFs); |
|
2874 IMPORT_C static CFileMan* NewL(RFs& aFs,MFileManObserver* anObserver); |
|
2875 ~CFileMan(); |
|
2876 IMPORT_C TAction CurrentAction(); |
|
2877 IMPORT_C void GetCurrentTarget(TFileName& aFile); |
|
2878 IMPORT_C void GetCurrentSource(TFileName& aFile); |
|
2879 IMPORT_C TInt BytesTransferredByCopyStep(); |
|
2880 public: |
|
2881 IMPORT_C TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch=0); |
|
2882 IMPORT_C TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch,TRequestStatus& aStatus); |
|
2883 IMPORT_C TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite); |
|
2884 IMPORT_C TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus); |
|
2885 IMPORT_C TInt Delete(const TDesC& aName,TUint aSwitch=0); |
|
2886 IMPORT_C TInt Delete(const TDesC& aName,TUint aSwitch,TRequestStatus& aStatus); |
|
2887 IMPORT_C TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite); |
|
2888 IMPORT_C TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus); |
|
2889 IMPORT_C TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite); |
|
2890 IMPORT_C TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus); |
|
2891 IMPORT_C TInt RmDir(const TDesC& aDirName); |
|
2892 IMPORT_C TInt RmDir(const TDesC& aDirName,TRequestStatus& aStatus); |
|
2893 IMPORT_C TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches=EOverWrite); |
|
2894 IMPORT_C TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches,TRequestStatus& aStatus); |
|
2895 protected: |
|
2896 CFileMan(RFs& aFs); |
|
2897 TInt RenameInvalidEntry(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite); |
|
2898 private: |
|
2899 /** |
|
2900 This is an internal enumeration for CFileMan implementation. |
|
2901 THis enumeration is mapped into TAction when user wants to identify the current |
|
2902 task of CFileMan by CurrentAction(). |
|
2903 |
|
2904 @see CFileMan::TAction |
|
2905 @see CFileMan::CurrentAction |
|
2906 */ |
|
2907 enum TInternalAction |
|
2908 { |
|
2909 /** |
|
2910 Internal indicator for None operation. |
|
2911 This is mapped to CFileMan::ENone. |
|
2912 */ |
|
2913 EInternalNone, |
|
2914 |
|
2915 /** |
|
2916 Internal indicator for Attribs() operation. |
|
2917 This is mapped to CFileMan::EAttribs. |
|
2918 */ |
|
2919 EInternalAttribs, |
|
2920 |
|
2921 /** |
|
2922 Internal indicator for Copy() operation. |
|
2923 This is mapped to CFileMan::ECopy. |
|
2924 */ |
|
2925 EInternalCopy, |
|
2926 |
|
2927 /** |
|
2928 Internal indicator for Delete() operation. |
|
2929 This is mapped to CFileMan::EDelete. |
|
2930 */ |
|
2931 EInternalDelete, |
|
2932 |
|
2933 /** |
|
2934 Internal indicator for Move() operation on different drives. |
|
2935 This is mapped to CFileMan::Move. |
|
2936 */ |
|
2937 EInternalCopyForMove, |
|
2938 |
|
2939 /** |
|
2940 Internal indicator for Move() operation on the same drive. |
|
2941 This is mapped to CFileMan::Rename. |
|
2942 Note for compatibility reasons, it is not mapped to CFileMan::Move. |
|
2943 */ |
|
2944 EInternalRenameForMove, |
|
2945 |
|
2946 /** |
|
2947 Internal indicator for Rename() operation. |
|
2948 This is mapped to CFileMan::ERename. |
|
2949 */ |
|
2950 EInternalRename, |
|
2951 |
|
2952 /** |
|
2953 Internal indicator for RmDir() operation. |
|
2954 This is mapped to CFileMan::ERmDir. |
|
2955 */ |
|
2956 EInternalRmDir, |
|
2957 |
|
2958 /** |
|
2959 Internal indicator for RenameInvalidEntry() operation. |
|
2960 This is mapped to CFileMan::ERenameInvalidEntry. |
|
2961 */ |
|
2962 EInternalRenameInvalidEntry, |
|
2963 |
|
2964 /** |
|
2965 Internal indicator for CopyFromHandle() operation. |
|
2966 This is mapped to CFileMan::ECopyFromHandle. |
|
2967 */ |
|
2968 EInternalCopyFromHandle, |
|
2969 }; |
|
2970 |
|
2971 void CompleteOperationL(); |
|
2972 void DoOperationL(); |
|
2973 void CheckForDirectory(); |
|
2974 void SetFlags(TBool aOverWrite,TBool aRecurse,TBool aScanDirection,TBool aMoveRename); |
|
2975 void GetSrcAndTrg(TParse& aSrcName,TFileName& aTrgName); |
|
2976 void DoSynchronize(TInt aRetVal); |
|
2977 TInt CheckRenameAllowed(const TDesC& aSrcName,const TDesC& aTrgName); |
|
2978 TInt SetupMoveOnSameDrive(TUint aSwitches, TBool& aComplete); |
|
2979 TInt SetupMoveAcrossDrives(TUint aSwitches); |
|
2980 TInt SetupTargetDirectory(TBool aOverWrite, TBool& aComplete); |
|
2981 TBool SrcTrgDrivesIdentical(); |
|
2982 TInt SetupDirectoryForMove(TBool& aSrcIsDir); |
|
2983 private: |
|
2984 void DoAttribsL(); |
|
2985 void DoCopyOrMoveL(); |
|
2986 void DoDeleteL(); |
|
2987 void DoRenameL(); |
|
2988 void DoRmDirL(); |
|
2989 void DoCopyFromHandleL(); |
|
2990 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
2991 TInt DoCopy(const RFile& aSrcFile, RFile& aDstFile, TInt& aRet); |
|
2992 #else |
|
2993 TInt DoCopy(const RFile64& aSrcFile, RFile64& aDstFile, TInt& aRet); |
|
2994 #endif |
|
2995 private: |
|
2996 TParse iTrgFile; |
|
2997 TInternalAction iAction; |
|
2998 TUint iSetMask; |
|
2999 TUint iClearMask; |
|
3000 TTime iTime; |
|
3001 TInt iBytesTransferred; |
|
3002 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
3003 RFile iSrcFileHandle; |
|
3004 #else |
|
3005 RFile64 iSrcFileHandle; |
|
3006 #endif |
|
3007 TBool iMovingContents; |
|
3008 TEntry iTmpEntry; |
|
3009 TParse iTmpParse; |
|
3010 TFileName iTmpName1; |
|
3011 TFileName iTmpName2; |
|
3012 |
|
3013 friend void RenameInvalidEntryL(RFs& aFs,TParse& aSrcFile); |
|
3014 }; |
|
3015 |
|
3016 |
|
3017 |
|
3018 |
|
3019 class TFindFile |
|
3020 /** |
|
3021 @publishedAll |
|
3022 @released |
|
3023 |
|
3024 Searches for files and directories. |
|
3025 |
|
3026 Each function has a variant which searches for multiple files/directories, |
|
3027 using one or more wildcard characters in the filename. |
|
3028 If an initial search is successful, further searches can be carried out |
|
3029 using Find() or FindWild(). |
|
3030 You can also retrieve the fully qualified file specification, |
|
3031 and manipulate and interrogate it using the TParse class (or related classes). |
|
3032 |
|
3033 Note that when specifying the path of a directory to search, the path should |
|
3034 always end with a backslash character.When trailing backslash is not present |
|
3035 then it is considered as file. And path will be taken till last backslash. |
|
3036 The client must have appropriate capabilities for the directory to be searched. |
|
3037 For example without ALL FILES Capability, it is not possible to successfully |
|
3038 find any files under \sys\bin directory. |
|
3039 |
|
3040 By default if the file is not found in the current drive the rest of the drives, |
|
3041 excluding the remote ones, will be searched. Using function SetFindMask it is |
|
3042 possible to specify a combination of drive attributes(aMask) that the drives to |
|
3043 be searched must match. |
|
3044 |
|
3045 */ |
|
3046 { |
|
3047 public: |
|
3048 IMPORT_C TFindFile(RFs& aFs); |
|
3049 IMPORT_C TInt FindByPath(const TDesC& aFileName,const TDesC* aPathList); |
|
3050 IMPORT_C TInt FindByDir(const TDesC& aFileName,const TDesC& aDirPath); |
|
3051 IMPORT_C TInt Find(); |
|
3052 IMPORT_C TInt FindWildByPath(const TDesC& aFileName,const TDesC* aPathList,CDir*& aDirList); |
|
3053 IMPORT_C TInt FindWildByDir(const TDesC& aFileName,const TDesC& aDirPath,CDir*& aDir); |
|
3054 IMPORT_C TInt FindWild(CDir*& aDirList); |
|
3055 IMPORT_C TInt SetFindMask(TUint aMask); |
|
3056 inline const TDesC& File() const; |
|
3057 private: |
|
3058 TInt DoFind(); |
|
3059 TInt DoFindByPath(const TDesC& aFileName,const TDesC* aPathList); |
|
3060 TInt DoFindByDir(const TDesC& aFileName,const TDesC& aDir); |
|
3061 TInt DoFindInDir(); |
|
3062 TInt DoFindNextInPath(); |
|
3063 TInt DoFindNextInDriveList(); |
|
3064 private: |
|
3065 RFs* const iFs; |
|
3066 TParse iFile; |
|
3067 TInt iPathPos; |
|
3068 TInt iCurrentDrive; |
|
3069 TInt iMode; |
|
3070 const TDesC* iPath; |
|
3071 TDriveList iDrvList; |
|
3072 CDir** iDir; |
|
3073 TUint32 iMatchMask; |
|
3074 }; |
|
3075 |
|
3076 |
|
3077 |
|
3078 |
|
3079 /** |
|
3080 @publishedAll |
|
3081 @released |
|
3082 |
|
3083 Contains a list of entries for the files which were opened in |
|
3084 a file server session. |
|
3085 |
|
3086 @see CDir |
|
3087 */ |
|
3088 typedef CDir CFileList; |
|
3089 |
|
3090 |
|
3091 |
|
3092 |
|
3093 class TOpenFileScan |
|
3094 /** |
|
3095 @publishedAll |
|
3096 @released |
|
3097 |
|
3098 Scans open files to get a list of the entries for all files which are currently |
|
3099 open in a particular file server session. |
|
3100 |
|
3101 NextL() creates a list of the files opened by the session. |
|
3102 The ID of the thread which opened the files listed may be obtained by calling ThreadId(). |
|
3103 If multiple sessions are in use, repeatedly calling NextL() will return a list |
|
3104 of open files in each session. |
|
3105 */ |
|
3106 { |
|
3107 public: |
|
3108 IMPORT_C TOpenFileScan(RFs& aFs); |
|
3109 IMPORT_C void NextL(CFileList*& aFileList); |
|
3110 IMPORT_C TThreadId ThreadId() const; |
|
3111 private: |
|
3112 RFs* iFs; |
|
3113 TThreadId iThreadId; |
|
3114 TInt iScanPos; |
|
3115 TInt iEntryListPos; |
|
3116 }; |
|
3117 |
|
3118 |
|
3119 |
|
3120 |
|
3121 class TFileText |
|
3122 /** |
|
3123 @publishedAll |
|
3124 @released |
|
3125 |
|
3126 Reads and writes single lines of text to or from a Unicode file. |
|
3127 */ |
|
3128 { |
|
3129 private: |
|
3130 enum TFileState |
|
3131 { |
|
3132 EStartOfFile, |
|
3133 ENormal, |
|
3134 EReverse |
|
3135 }; |
|
3136 public: |
|
3137 IMPORT_C TFileText(); |
|
3138 IMPORT_C void Set(RFile& aFile); |
|
3139 IMPORT_C TInt Read(TDes& aDes); |
|
3140 IMPORT_C TInt Write(const TDesC& aDes); |
|
3141 IMPORT_C TInt Seek(TSeek aMode); |
|
3142 private: |
|
3143 void NextRecord(); |
|
3144 TInt CheckForTerminator(TBool& anAnswer); |
|
3145 TInt FillBuffer(); |
|
3146 private: |
|
3147 const TText* iNext; |
|
3148 const TText* iEnd; |
|
3149 TFileState iState; |
|
3150 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
3151 RFile iFile; |
|
3152 #else |
|
3153 RFile64 iFile; |
|
3154 #endif |
|
3155 TBuf8<0x100> iReadBuf; |
|
3156 }; |
|
3157 |
|
3158 |
|
3159 |
|
3160 |
|
3161 /** |
|
3162 @publishedAll |
|
3163 @released |
|
3164 */ |
|
3165 IMPORT_C TBool FileNamesIdentical(const TDesC& aFileName1,const TDesC& aFileName2); |
|
3166 |
|
3167 /** |
|
3168 @publishedAll |
|
3169 @released |
|
3170 |
|
3171 The UID of the File Server process |
|
3172 */ |
|
3173 const TInt KFileServerUidValue = 0x100039e3; |
|
3174 |
|
3175 |
|
3176 #include <f32file.inl> |
|
3177 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
3178 #include <f32file64.inl> |
|
3179 #endif |
|
3180 |
|
3181 #ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION |
|
3182 #include <f32notification.h> |
|
3183 #endif |
|
3184 |
|
3185 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
3186 #include <f32file_private.h> |
|
3187 #endif |
|
3188 |
|
3189 #endif |