PHP Ionic Angularjs Phonegap AJAX Javascript CSS MySQL jQuery Forum

การจัดเก็บข้อมูล แบบบันทึกเป็นไฟล์ ของระบบ andorid ตอนที่ 2

05 August 2015 By


กลับมาแล้วกับเนื้อหาการศึกษา android จากตัวอย่าง 
http://developer.android.com/training/basics/data-storage/files.html
 
เนื้อหาส่วนนี้ก็จะมาต่อในส่วนของการจัดเก็บข้อมูล แบบบันทึกเป็นไฟล์
ก่อนเข้าสู่รายละเอียดขอทำความเข้าใจอีกครั้ง ดังนี้
บทความต่อไปนี้เป็นการพยายามแปลและทำความเข้าใจจากต้นฉบับ มีดัดแปลงหรือประยุกต์บ้างใน
บางตอนตามความเข้าใจของผู้เขียนบทความ ซึ่งกำลังศึกษาระบบ android ตั้งแต่เริ่มต้น
ดังนั้นอาจจะมีการใช้คำหรือภาษาที่แปลก หรือไม่ถูกต้อง ผู้อ่านโปรดพิจารณาตามความเหมาะสม
หรือสามารถศึกษาได้ด้วยตัวอย่าง จากต้นฉบับได้เลย
แต่ถ้าใครเพิ่งฝึกเหมือนกัน ก็สามารถดูเนื้อหาของผู้เขียนประกอบไปด้วยก็ได้ 
ในตอนนี้ จะไม่มีตัวอย่างการเขียนโค้ดหรือ app ตัวอย่าง แต่จะมีเพิ่มในตอนหน้า
เป็นการประยุกต์ หรือทดสอบการจัดเก็บข้อมูลแบบบันทึกเป็นไฟล์ 
 
 
การจัดเก็บข้อมูล แบบบันทึกเป็นไฟล์
 
android มีระบบจัดการไฟล์คล้ายระบบของการจัดการพื้นที่จัดเก็บไฟล์ของแพล็ทฟอร์มอื่น
เนื้อหาในส่วนนี้เราจะมารู้จักกับการใช้งานระบบไฟล์ใน android ด้วย File API ในการอ่าน
และเขียนไฟล์
 
File Object เหมาะกับใช้อ่านหรือเขียนไฟล์ข้อมูลขนาดใหญ่ จากเริ่มต้นไปจนสิ้นสุดไฟล์ตามลำดับ
โดยไม่ต้องกระโดดไปมาในขั้นตอนการเขียนไฟล์ ยกตัวอย่างเช่น ไฟล์รูปภาพหรือการไฟล์อื่นๆ 
ที่มีการแลกเปลี่ยน กันภายในระบบเครือข่าย
 
การแสดงให้เห็นพื้นฐานความสัมพันธ์ของหน้าที่ไฟล์ใน app ของเรา โดยสมมติ
เสมือนว่าเรากำลังใช้งานระบบไฟล์บนพื้นฐานของระบบของ Linux และการใช้งานมาตรฐาน
input/output API ไฟล์ของ ของ java.io อยู่
 
 
การเลือกพื้นที่จัดเก็บภายใน หรือ พื้นที่จัดเก็บภายนอก
 
อุปกรณ์ android จะมีพื้นที่จัดเก็บข้อมูลไฟล์อยู่สองส่วน "internal" และ "external"
หรือก็คือพื้นที่จัดเก็บภายใน และพื้นที่จัดเก็บภายนอก  ชื่อเหล่านี้มีมาตั้งแต่ต้นในระบบ android
แล้ว นับตั้งแต่อุปกรณ์ส่วนใหญ่ได้ให้หน่วยความจำเครื่องแบบจำกัด(พื้นที่จัดเก็บภายใน) บวกกับ
พื้นที่จัดเก็บขนาดกลางที่สามารถถอดออกได้ เช่น micro SD card (พื้นที่จัดเก็บภายนอก)
ในบางอุปกรณ์มีการแบ่งพื้นที่จัดเก็บถาวรแบ่งแยกออกเป็น "internal" และ "external" ถึงแม้จะไม่
มีพื้นที่จัดเก็บขนาดกลางที่ถอดออกได้ ก็ยังพื้นที่จัดเก็บสองส่วนเสมอ และมี API ในการใช้งาน
เหมือนกันแม้ว่าพื้นที่จัดเก็บภายนอกจะสามารถถอดออกได้หรือไม่ก็ตาม รายการด้านล่างจะสรุป
ข้อเท็จจริงของพื้นที่จัดเก็บแต่ละแบบ
 
internal storage
 
    - จะมีพื้นจัดเก็บนี้อยู่ตลอดเสมอ
    - ไฟล์ที่ถูกบันทึกไว้ในนี้ โดยค่าเริ่มต้นจะสามารถเข้าถึงได้เฉพาะ app ของเราเท่านั้น
    - เมื่อผู้ใช้ถอนการติดตั้ง app ของเรา  ระบบจะลบไฟล์ทั้งหมดของ app จากที่จัดเก็บนี้
 
พื้นที่จัดเก็บภายใน เป็นทางเลือกที่ดีเมื่อเราต้องการมั่นใจว่าทั้งผู้ใช้และ app อื่นจะไม่สามารถเข้า
ถึงไฟล์เหล่านี้ได้
 
External storage
 
    - พื้นที่จัดเก็บนี้จะไม่ได้มีอยู่ตลอด เพราะถ้าผู้ใช้มีการดำเนินการให้พื้นที่ภายนอกนี้ใช้เป็น
      พื้นที่จัดเก็บ USB เช่นต่อเข้ากับ PC เป็น drive หนึ่งของ PC หรือกรณีพื้นที่จัดเก็บถูกถอดออก
    - ไฟล์สามารถถูกอ่านได้จากทุกๆที่ ดังนั้นไฟล์ที่บันทึกในนี้อาจจะถูกอ่าน นอกเหนือการควบคุมได้
    - เมื่อผู้ใช้ถอนการติดตั้ง app ของเรา  ระบบจะลบไฟล์ของ app จากพื้นที่จัดเก็บนี้ก็ต่อเมื่อผู้ใช้
      บันทึกไฟล์นั้นจากการใช้งาน getExternalFilesDir() เท่านั้น
 
พื้นที่จัดเก็บภายนอก เป็นทางเลือกที่ดีสำหรับไฟล์ที่ไม่ได้มีการจำกัดการเข้าถึงและเป็นไฟล์ที่เราต้อง
การที่จะใช้ร่วมกับ app อื่น หรืออนุญาตให้ผู้ใช้งานข้าถึงไฟล์ได้จาก computer
 
 
เคล็ดลับ:: แม้ว่า app ได้ถูกติดตั้งลงพื้นที่จัดเก็บภายในโดยค่าเริ่มต้นแล้วก็ตาม แต่เรายังสามารถที่จะ
กำหนด android:installLocation attribute ลงในส่วนของไฟล์ manifest ให้ app ของเราสามารถที่จะ
ติดตั้งลงพื้นที่จัดเก็บภายนอกได้  ซึ่งผู้ใช้จะเลือกตัวเลือกที่เหมาะสมนี้เมือไฟล์ APK มีขนาดใหญ่
และพวกเขามีพื้นที่จัดเก็บภายนอกเหลือมากกว่าพื้นที่จัดเก็บภายใน 
 
 
การกำหนดสิทธิ์การใช้งานพื้นที้จัดเก็บภายนอก
 
เพื่อที่เราจะสามารถเขียนไฟล์ลงพื้นที่จัดเก็บภายนอกได้ เราจำเป็นต้องร้องขอสิทธิ์ การใช้งาน 
WRITE_EXTERNAL_STORAGE โดยการกำหนดในไฟล์ manifest ดังนี้
 
<manifest ...>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    ...
</manifest>
 
ข้อควรระวัง:: ในปัจจุบัน app ทั้งหมดสามารถที่จะอ่านไฟล์จากพื้นที่จัดเก็บภายนอกโดยไม่ต้องของสิทธ์
อนุญาตเพิ่มเติม  แต่อย่างไรก็ตามในอนาคตอาจมีการเปลี่ยนเปลง   ถ้า app ของเราจำเป็นต้องอ่านไฟล์
จากพื้นที่จัดเก็บภายนอก (โดยไม่ได้เขียนไฟล์ลงไปในพื้นที่จัดเก็บภายนอก) แล้ว เราจำเป็นที่จะต้องกำหนด
การร้องขอสิทธ์การอ่านไฟล์ READ_EXTERNAL_STORAGE  เพื่อให้มั่นใจว่า app ของเราจะสามารถทำงาน
ได้ตามที่คาดไว้ โดยเราควรจะเปลี่ยนสิทธิ์การร้องขอโดยทันที
 
<manifest ...>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    ...
</manifest>
 
อย่างไรก็ตามถ้า app ของเรากำหนด WRITE_EXTERNAL_STORAGE ตั้งแต่ต้นเพราะ app ของเราจำเป็น
ต้องมีการเขียนไฟล์ลงพื้นที่จัดเก็บภายนอก โดยนัยแล้วสิทธฺิ์ในการอ่านไฟล์จะสามารถทำได้เลยโดยไม่ต้อง
กำหนดเพิ่มใดๆ สรุปก็คือถ้ากำหนดให้เขียนได้แล้วก็ไม่ต้องกำหนดให้อ่านเพราะได้รับสิทธิ์ส่วนนั้นไปพร้อมกัน
 
 
ในส่วนของพื้นที่จัดเก็บภายในหรือความจำเครื่อง เราไม่ต้องกำหนดการร้องขอสิทธิ์ในการบันทึกไฟล์ app จะ
ได้ระบอนุญาตในการอ่านและเขียนไฟล์ลงในพื้นที่จัดเก็บภายในอยู่แล้วเสมอ
 
 
การบันทึกไฟล์ลงพื้นที่จัดเก็บภายใน
 
เมื่อจะทำการบันทึกไฟล์ลงพื้นที่จัดเก็บภายใน เราจะได้โฟลเดอร์ที่ต้องการจาก File Object โดยการเรียกใช้งาน
สอง method ต่อไปนี้
 
getFilesDir()
 
คืนค่า File Object ที่แสดง โฟลเดอร์ภายในสำหรับ app ของเรา
 
getCacheDir()
 
คืนค่า File Object ที่แสดง โฟลเดอร์ภายในสำหรับ app ของเราเป็นไฟล์ แคชชั่วคราว โดยมั่นใจว่า
ไฟล์นี้จถูกลบออกเมื่อไม่จำเป็นต้องใช้งานและประกอบกับขนาดที่จำกัดของประมาณหน่วยความจำที่ใข้
ในขณะเวลานั้น เช่น 1MB ถ้าระบบเริ่มมีปริมาณพื้นที่จักเก็บน้อย ระบบอาจจะลบไฟล์แคชนั้น
โดยไม่มีการเตือนใดๆ
 
ในการสร้างไฟล์ใหม่ลงในโฟลเดอร์ เราสามารถใช้งาน File() constructor โดยการเรียกใช้หนึ่งใน method
จากที่กล่าวมาแล้วด้านบน เพื่อระบุโฟลเดอร์ที่จะจักเก็บในพื้นที่ภายใน ตัวอย่าง
 
File file = new File(context.getFilesDir(), filename);
 
หรืออีกทางเลือกหนึ่ง เราสามารถเรียกใช้งาน openFileOutput() เพื่อให้ FileOutputStream นั้นทำการเขียนไฟล์
ลงในโฟลเดอร์ภายใน ยกตัวอย่าง เช่น การเขียน text ไฟล์
 
String filename = "myfile";
String string = "Hello world!";
FileOutputStream outputStream;

try {
  outputStream = openFileOutput(filename, Context.MODE_PRIVATE);
  outputStream.write(string.getBytes());
  outputStream.close();
} catch (Exception e) {
  e.printStackTrace();
}
 
 
หรือกรณีถ้าเราจำเป็นต้องการแคชไฟล์ เราควรใช้ createTempFile() แทน ยกตัวอย่าง 
วิธีการแยกชือไฟล์ออกมาจาก url และสร้างไฟล์ด้วยชื่อนั้นในแคชโฟลเดอร์ใน app ของเรา
 
public File getTempFile(Context context, String url) {
    File file;
    try {
        String fileName = Uri.parse(url).getLastPathSegment();
        file = File.createTempFile(fileName, null, context.getCacheDir());
    catch (IOException e) {
        // Error while creating file
    }
    return file;
}
 
ข้อสังเกต:: โฟลเดอร์พื้นที่จัดเก็บภายในของ app ของเราระบุโดยชื่อ app package ในตำแหน่ง
เฉพาะของระบบไฟล์ของ android. โดยในทางเทคนิค app อื่นสามารถอ่านไฟล์นั้นได้ถ้าเรากำหนดให้
ไฟล์นั้นสามารถอ่านได้ อย่างไรก็ตามก็ยังต้องรู้ชื่อ app package และชื่อไฟล์ด้วย
ซึ่ง app อื่นๆ ไม่สามารถค้นหาโฟลเดอร์ภายในของเรา และจะอ่านหรือเขียนไม่ได้ เว้นแต่เราได้กำหนดชัดเจนไว้ก่อนว่า
ไฟล์นั้นๆ สามารถอ่านหรือเขียนได้  ดังนั้นตราบใดที่เราใช้งาน MODE_PRIVATE กับไฟล์ในพื้นที่จัดเก็บภายใน
ไฟล์นั้นก็จะไม่สามารถเข้าถึงได้จาก app อื่น
 
 
การบันทึกไฟล์ลงพื้นที่จัดเก็บภายนอก
 
 
ด้วยเหตุผลที่พื้นที่จัดเก็บภายนอกอาจจะใช้งานไม่ได้ เช่นเมื่อผู้ใช้ต่อเข้าเครื่อง PC เป็น usb drive หรือ
มีการถอด SD card ออก ดังนั้นเราควรจะตรวจสอบเพื่อยืนยันว่ามีพื้นที่จัดเก็บนี้อยู่หรือไม่ก่อนใช้งานเสมอ
โดยเราสามารถเรียกดูสถานะของพื้นที่จัดเก็บภายนอกนี้ด้วยคำสั่ง getExternalStorageState() ซึ่งถ้าค่าที่
ส่งกลับมามีค่าเท่ากับ MEDIA_MOUNTED นั่นแล้วเราสามารถที่จะอ่่านหรือเขียนไฟล์ได้ ยกตัวอย่างวิธี
การใช้งานต่อไปนี้ ซึ่งมีประโยชน์มากในการเป็นตัวกำหนดว่ามีเพื้นที่จัดเก็บนั้นอยู่
 
/* ตรวจสอบว่ามีพื้นที่จัดเก็บภายนอกสำหรับอ่านและเขียนหรือไม่ */
public boolean isExternalStorageWritable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state)) {
        return true;
    }
    return false;
}

/* ตรวจสอบว่าพื้นที่จัดเก็บภายนอกอย่างน้อยมีพื้นที่สำหรับอ่านหรือไม่ */
public boolean isExternalStorageReadable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state) ||
        Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
        return true;
    }
    return false;
}
 
 
แม้ว่าพื้นที่จัดเก็บภายนอกจะสามารถแก้ไขได้จากผู้ใช้หรือ app อื่น  แต่จะมีไฟล์อยู่ 2 ประเภทที่จะสามารถจะบันทึกได้
 
 
Public files ไฟล์สาธารณะ
 
เป็นไฟล์ที่เข้าถึงได้จากผู้ใช้และ app อื่นอย่างอิสระ และเมื่อผู้ใช้ถอนการติดตั้ง app ไปแล้ว ไฟล์เหล่านี้ก็จะคงอยู่
ยกตัวอย่างเช่น รูปภาพที่เกิดจากการการใช้งาน app หรือ ไฟล์ที่ดาวน์โหลดอื่นๆ 
 
 
Private files ไฟล์พิเศษเฉพาะ
 
เป็นไฟล์ของ app นั้นและจะถูกลบเมื่อผู้ใช้ถอนการติดตั้ง app  แม้ว่าไฟล์เหล่านี้จะสามารถเข้าถึงได้ทางเทคนิคจาก
ผู้ใช้งานและ app อื่น เพราะอยู่บนพื้นที่จัดเก็บภายนอกก็ตาม โดยแท้จริงแล้วจะเป็นไฟล์ที่ไม่ให้ค่าใดๆ กับผู้ใช้ภายนอก app
เมื่อผู้ใช้ถอนการติดตั้ง app ระบบจะทำการลบไฟล์ทั้งหมดของ app ที่อยู่ในโฟลเดอร์ไฟล์เฉพาะนี้
ยกตัวอย่าง ทรัพยากรที่ดาวน์โหลดเพิ่มเติมของ app หรือ ไฟล์มีเดียชั่วคราว
 
 
ถ้าเราต้องการจะบันทึก public files ลงบนพื้นที่จัดเก็บภายนอก ให้ใช้  getExternalStoragePublicDirectory() เพื่อเรียก File Object
ที่แสดงถึงโฟลเดอร์ที่เหมาะสมบนพื้นที่จัดเก็บภายนอก คำสั่งนี้จะมีการกำหนดค่าประเภทของไฟล์เจาะจง ดังนั้นจึงสามารถ
ระเบียบให้สมเหตุสมผลกับ public file อื่น เช่น DIRECTORY_MUSIC หรือ DIRECTORY_PICTURES
 
ตัวอย่าง
 
public File getAlbumStorageDir(String albumName) {
    // ดึงค่าโฟลเดอร์รูปภาพที่ใช้งานร่วมกันของ ผู้ใช้  
    File file = new File(Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES), albumName);
    if (!file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}
 
 
ถ้าเราต้องการบันทึกไฟล์เฉพาะของ app เราสามารถเรียกดูโฟลเดอร์ที่เหมาะสมได้จากคำสั่ง 
getExternalFilesDir()  แล้วส่งค่าชื่อ ที่บ่งชื่อถึงประเภทของโฟลเดอร์ที่ต้องการใช้ 
แต่ละโฟลเดอร์ที่ถูกสร้างด้วยวิธีนี้จะถูกรวมเข้าไปในโฟลเดอร์หลักที่บรรจุโฟล์ในพื้นที่จัดเก็บ
ภายนอกทั้งหมด ซึ่งระบบจะทำการลบเมื่อผู้ใช้ ถอนการติดตั้ง app
ยกตัวอย่าง นี่คือคำสั่งที่เราสามารถใช้สร้างโฟลเดอร์สำหรับจัดเก็บอัลบั้มรูปภาพแยกเฉพาะได้
 
public File getAlbumStorageDir(Context context, String albumName) {
    // เรียกดูโฟลเดอร์สำหรับเก็บรูปภาพของอัลบั้มเฉพาะ
    File file = new File(context.getExternalFilesDir(
            Environment.DIRECTORY_PICTURES), albumName);
    if (!file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}
 
 
ถ้าไม่มีการกำหนดโฟลเดอร์ย่อยไว้ก่อนหน้าสำหรับจัดเก็บไฟล์ เราสามารถเรียกใช้ getExternalFilesDir()  แล้ว
ส่งค่าว่าง null เข้าไป ด้วยวิธีนี้้ ระบบจะส่งโฟลเดอร์ root ของโฟลเดอร์เฉพาะของ app บนพื้นที่จัดเก็บภาย
นอก
 
จำไว้ว่าคำสั่ง getExternalFilesDir() นั่นจะสร้างโฟลเดอร์ภายในโฟลเดอร์ที่จะถูกลบออกเมื่อทำการ
ถอนการติดตั้ง app  ถ้าหากว่าต้องการให้ไฟล์ที่ได้ทำการบันทึกไว้ยังคงอยู่หลังจากทำการถอนการติดตั้ง app แล้ว
เช่น เมื่อ app มีการใช้งานกล้อง และผู้ใช้ต้องการเก็บไฟล์รุปภาพไว้  กรณีนี้เราควรใช้คำสั่ง getExternalStoragePublicDirectory() แทน
 
หากไม่คำนึงถึงว่าการใช้ getExternalStoragePublicDirectory() สำหรับไฟล์ที่ต้องการใช้งานร่วมกัน 
หรือ getExternalFilesDir() สำหรับไฟล์ที่ต้องการใช้งานเฉพาะใน app เป็นสิ่งสำคัญที่ที่เราจะใช้ชื่อโฟลเดอร์
ที่กำหนดโดยค่าคงที่ของ API เช่น DIRECTORY_PICTURES 
ชื่อโฟลเดอร์นี้จะทำให้มั่นใจได้ว่าไฟล์มีการใช้งานถูกต้องตามระบบ อย่างกรณี ไฟล์ที่บันทึกลงใน
โฟลเดอร์ชื่อ DIRECTORY_RINGTONES ซึ่งจะถูกแยกประเภทด้วยระบบแสกนมีเดียให้อยู่ในหมวด 
ไฟล์ริงโทน แทนไฟล์ แพลง
 
 
การเรียกดูพื้นที่ว่าง
 
ถ้าเรารู้ก่อนว่าปริมาณข้อมูลเท่าไหร่ที่ต้องการบันทึก เราก็จะสามารถหาว่าพื้นที่ว่างที่เหมาะสมโดยไม่เกิด
เงื่อนไข IOException ด้วยการเรียกใช้งานคำสั่ง getFreeSpace() หรือ getTotalSpace() 
คำสั่งเหล่านี้เราจะทำให้เราได้ค่าพื้นที่ว่างปัจจุบันและพื้นที่ทั้งหมดของปริมาณพื้นที่จัดเก็บนั้นตามลำดับ
ข้อมูลที่ได้เหล่านี้จะมีประโยชน์อย่างมากเพื่อเลี่ยงการบันทึกข้อมูลเกินปริมาณที่พ้ื้นที่จัดเก็บนั้นๆ สามารถรับได้
 
อย่างไรก็ตาม ระบบไม่รับประกันได้ว่า เราสามารถเขียนข้อมูลได้ในปริมาณมากๆ  เท่ากับพื้นที่ว่างที่เหลือ
จริงจากการใช้งาน getFreeSpace() ซึ่งถ้ามีปริมาณจำนวนพื้นที่ว่างที่เหลืออยู่มีมากกว่าปริมาณข้อมูลที่จะบันทึก
ไม่กี่ MB หรือ ถ้าไฟล๋ระบบมีการใช้งานไปน้อยก่า 90% แล้วกระบวนการบันทึกไฟล์ก็สามารถทำได้
ตรงกันข้ามหากเป็นกรณีอื่นๆ เราก็จะไม่สามารถเริ่มกระบวนการบันทีกไฟล์ลงพื้นที่จัดเก็บได้
 
ข้อสังเกต:: เราไม่จำเป็นต้องตรวจสอบปริมาณพื้นที่ว่างก่อนทำการบันทึกไฟล์ โดยเราสามารถที่จะทำงานเพื่อทำการ
เขียนไฟล์ได้ทันที แล้วพิจารณาจากข้อยกเว้นกรณีที่ไม่สามารถเขียนไฟล์ได้จาก IOException ซึ่งบางทีเราจำเป็นต้องใช้
วิธีนี้ในกรณีถ้าเราไม่รู้ขนาดของพื้นที่ที่จำเป็นต้องใช้ในการบันทึก ยกตัวอย่าง ถ้าเราทำการเข้ารหัสไฟล์ก่อนทำการบันทึก
เช่น การแปลงไฟล์จาก PNG เป็น JPEG โดยที่เราไม่รู้ขนาดไฟล์มาก่อน
 
 
การลบไฟล์
 
เราควรจะทำการลบไฟล์ที่ไม่ได้ใช้งาน วิธีการที่เรียบง่ายที่สุดในการลบไฟล์ คือการเรียกใช้งานคำสั่ง delete()  จากไฟล์
นั้นๆ ตัวอย่าง
 
myFile.delete();
 
ถ้าเป็นไฟล์ที่บันทึกในพื้นที่จัดเก็บภายใน เราสามารถเรียกใช้งาน Context แล้วทำการลบไฟล์ด้วยคำสั่ง deleteFile()
ตัวอย่าง
 
myContext.deleteFile(fileName);
 
ข้อสังเกต::  เมื่อผู้ใช้ทำการถอนการติดตั้ง app   ระบบของ android จะทำการลบไฟล์ดังนี้
- ไฟล์ทุกไฟล์ที่ถูกบันทึกอยู่ในพื้นที่จัดเก็บภายในของ app นั้นๆ
- ไฟล์ทุกไฟล์ที่ถูกบันทึกอยู่ในพื้นที่จัดเก็บภายนอกที่ใช้งานคำสั่ง getExternalFilesDir() 
อย่างไรก็ตาม สำหรับการใช้งานตามปกติทั่วไป เราควรทำการลบไฟล์แคชทั้งหมดที่สร้างด้วยคำสั่ง getCacheDir() เอง
และควรที่จะลบไฟล์ที่ไม่ได้ใช้งานแล้วด้วย

Tags:: บันทึกไฟล์ การจัดเก็บข้อมูล android

เนื้อหาพิเศษ เฉพาะสำหรับสมาชิก

กรุณาล็อกอิน และลงชื่อติดตาม


สมัครสมาชิกได้ที่        ล็อกอินได้ที่   





URL สำหรับอ้างอิง