ContentProviders - מוסברים.

שלום שוב,

למי ששכח, הוקרה קצרה; הבלוג הזה מתבסס לחלוטין על עבודתי המשותפת עם +Ran Nachmany ו- +Amir Lazarovich על Developer lab בשם AndconLab שהעברנו בכנס MultiScreenX השנה.

בפוסט הקודם דיברנו על שימוש ב-ContentProviders אבל לא ממש הסברתי עליהם ולכך מוקדש הפוסט הזה, שבנוסף להוקרה למעלה גם מבוסס על הרצאה שהעברתי בכנס של "רברס עם פלטפורמה".

מה?

אתם בוודאי שואלים למה אני לוקח צעד אחורה מפוסטים של "לעשות את זה נכון" בשביל הסבר על נושא פשוט כביכול, כזה של מתחילים?

ובכן התשובה לכך היא נקודה שהעברתי גם בהרצאה והיא שלמרות ש-ContentProviders הינם איתנו החל מרמת API 1 אני נתקל שוב ושוב במקרים בהם מפתחים:

• לא יודעים מה זה ContentProviders.
• לא משתמשים נכון ב-ContentProviders.
• לא משתמשים מספיק ב-ContentProviders.
• מפחדים להשתמש ב-ContentProviders.

ואת זה אני פה כדי לשנות, אז בואו נתחיל.

למה?

המוטיבציה להשתמש בכלי הזה יכולה להפרט ל-8 סעיפים:

1. שמירה של מידע בצורה א-נדיפה.
2. תמיכה בשמירה של כמות מידע גדולה בתקורה נמוכה יחסית.
3. אינדוקס וחיפוש מהיר במידע השמור. 
4. גישה אפשרית מתהליכים חיצוניים (Services, Applications, Activities).
5. אי-תלות בגישה לרשת.
6. יכולת הקמה קצרה יחסית במעט ידע וניסיון.
7. גמישות הנובעת בשמירה של כמעט כל סוג מידע במנגנון אחד.
8. תמיכה של הפלטפורמה.

שימו לב שתתי קבוצות של 8 הסעיפים הללו יכולות להגדיר מספר רב של מנגנונים בהם משתמשים רבים מן המפתחים, כך למשל:

• SharedPreferences - עונה על 1, 4 ,5, 8 אבל הן אינן נותנות את הגמישות, ויכולת החיפוש במידע השמור.
• תבניות פיתוח של memory caching יענו בצורה נפלאה על 2, 3, 6, 7 אבל לא יתנו מענה בשימוש ללא רשת.
• Cloud storage יכול להיות פתרון נפלא אבל גם הוא לא יעבוד ללא אינטרנט.
• ספריות ORM צד שלישי כמו - greenDAO או ORMlite למעשה כל הסעיפים מלבד # ואולי 6 אך עדכון תמידי של הגרסאות הוא כורח המציאות ויש אף אפשרות ששינויים עתידיים במערכת ההפעלה ישברו את הפונקציונליות כלל מטעמים של Security.

 אבל רק ContentProviders מספקים את כל 8 הסעיפים (למיטב ידיעתי). 

איך?

בואו נתחיל ממצב בוא יש לכם אפליקציה שמודל הנתונים שלה מכיל אוביקט מסוג item שנראה כך:

 public class Event{ 
   //////////////////////////////////////////  
   // Members  
   //////////////////////////////////////////  
   @JsonProperty("id") private long mId;  
   @JsonProperty("name") private String mName;  
   @JsonProperty("description") private String mDescription;  
   private List<Lecture> mLectures;  
   @JsonProperty("logo_url") private String mLogoUrl;  
   @JsonProperty("website_url") private String mWebsiteUrl;  
   @JsonProperty("start_date") private String mStartDate;  
   @JsonProperty("end_date") private String mEndDate;  
   //////////////////////////////////////////  
   // Public  
   ////////////////////////////////////////// 

      //Do something!
 
   //////////////////////////////////////////  
   // Getters & Setters  
   ////////////////////////////////////////// 

     //Do something more. 

מה שיש לנו כרגע הם השדות שמרכיבים את האובייקט ו- getters & setters.
מה שצריך להוסיף זה:

•  תמיכה בהמרה של המידע לפורמט סריאלי כך שניתן לשרשר אותו ולכן ה-Event יצטרך לממש את הממשק       Serializable. 
• הגדרה של העמודות בטבלת הנתונים שלנו שתשמר ב-sqlite.

התוצאה תראה כך:

 public class Event implements Serializable {  
   public static final String TABLE_NAME = "events";  
   public static final String COLUMN_NAME_ID = "_id";  
   public static final String COLUMN_NAME_NAME = "name";  
   public static final String COLUMN_NAME_DESCRIPTION = "description";  
   public static final String COLUMN_NAME_LOGO_URL = "logo_url";  
   public static final String COLUMN_NAME_WEBSITE_URL = "website_url";  
   public static final String COLUMN_NAME_START_DATE = "start_date";  
   public static final String COLUMN_NAME_END_DATE = "end_date";  
   //////////////////////////////////////////  
   // Members  
   //////////////////////////////////////////  
   @JsonProperty("id") private long mId;  
   @JsonProperty("name") private String mName;  
   @JsonProperty("description") private String mDescription;  
   private List<Lecture> mLectures;  
   @JsonProperty("logo_url") private String mLogoUrl;  
   @JsonProperty("website_url") private String mWebsiteUrl;  
   @JsonProperty("start_date") private String mStartDate;  
   @JsonProperty("end_date") private String mEndDate;  
   //////////////////////////////////////////  
   // Public  
   //////////////////////////////////////////  
   public ContentValues getContentValues() {  
     ContentValues cv = new ContentValues();  
     cv.put(COLUMN_NAME_DESCRIPTION, mDescription);  
     cv.put(COLUMN_NAME_END_DATE, mEndDate);  
     cv.put(COLUMN_NAME_ID, mId);  
     cv.put(COLUMN_NAME_LOGO_URL, mLogoUrl);  
     cv.put(COLUMN_NAME_NAME, mName);  
     cv.put(COLUMN_NAME_START_DATE, mStartDate);  
     cv.put(COLUMN_NAME_WEBSITE_URL, mWebsiteUrl);  
     return cv;  
   }  
   //////////////////////////////////////////  
   // Public  
   //////////////////////////////////////////  
   //////////////////////////////////////////  
   // Getters & Setters  
   //////////////////////////////////////////  

השלב הבא הוא להגדיר את הבנאי של טבלת ה-sqlite שלכם ומה החוקים שלה, זה נעשה ע"י יצירת extension            ל-SQLiteOpenHelper ודריסת כל המתודות שתרצו שיתנהגו בצורה מיוחדת, וזה יראה כך:

 public class DatabaseHelper extends SQLiteOpenHelper{  
      public static final String DB_NAME = "db";  
      public static final int DB_VERSION = 7;  
      public static final String LECTURE_SPEAKER_PAIT_TABLE = "lecture_speaker_pair";  
      public static final String PAIR_LECTURE_ID = "lecture_id";  
      public static final String PAIR_SPEAKER_ID = "speaker_id";  
      public DatabaseHelper(Context context, String name, CursorFactory factory,  
                int version) {  
           super(context, name, factory, version);  
      }  
      @Override  
      public void onCreate(SQLiteDatabase db) {  
           // create events table  
           StringBuilder sb = new StringBuilder();  
           try {  
           DBUtils.createTable(db, sb,   
                     Event.TABLE_NAME,  
                     Event.COLUMN_NAME_ID, "INTEGER PRIMARY KEY ",  
                     Event.COLUMN_NAME_NAME, "TEXT",  
                     Event.COLUMN_NAME_DESCRIPTION, "TEXT",  
                     Event.COLUMN_NAME_START_DATE, "TEXT",  
                     Event.COLUMN_NAME_END_DATE, "TEXT",  
                     Event.COLUMN_NAME_LOGO_URL, "TEXT",  
                     Event.COLUMN_NAME_WEBSITE_URL, "TEXT");  
      }  
      @Override  
      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
           StringBuilder sb = new StringBuilder();  
           DBUtils.dropTable(db,sb , Event.TABLE_NAME);  
           onCreate(db);  
      }  
 }  

שימו לב למספר דברים:

1. ב-OnCreate של ה-sqlite אנחנו יוצרים טבלה ייחודית ל-Event כאשר העמודות הן מה שהגדרנו מקודם באובייקט מסוג Event.
2. בכל upgrade של ה-sqlite אנחנו מוחקים את הטבלה ומתחילים מאפס, זה פתרון נאיבי ויש יותר טובים אבל בשביל ההתחלה הוא טוב מספיק.
3. שם ה-sqlite (כמו כל השאר) נקבע על ידינו פה בשורה הזו: 

public static final String DB_NAME = "db"; 

כעת, אחרי שיש לנו אובייקט לשים בטבלה והגדרה של מסד נתונים (sqlite) ושל טבלה, הגיע הזמן לממש את פעולות ה-CRUD של מסד הנתונים שלנו:

 public class DBUtils {  
      private static final String TAG = "DBUtils";  
      //select lecturerImage from assets where lectureVideoId='Y4UMzOWcgGQ';  
      /**  
       * Create DB table  
       *  
       * @param db    Reference to the underlying database  
       * @param sb    Clears any existing values before starting to append new values  
       * @param tableName The name of the DB table  
       * @param columns  Tuples of column names and their corresponding type and properties. This field must be even for that same  
       *         reason. I.e. "my_column", "INTEGER PRIMARY KEY AUTOINCREMENT", "my_second_column", "VARCHAR(255)"  
       */  
      public static void createTable(SQLiteDatabase db, StringBuilder sb, String tableName, String... columns) {  
           if (columns.length % 2 != 0) {  
                throw new IllegalArgumentException(  
                          "Columns length should be even since each column is followed by its corresponding type and properties");  
           }  
           StringUtils.clearBuffer(sb);  
           // Prepare table  
           sb.append("CREATE TABLE ");  
           sb.append(tableName);  
           sb.append(" (");  
           // Parse all columns  
           int length = columns.length;  
           for (int i = 0; i < length; i += 2) {  
                sb.append(columns[i]);  
                sb.append(" ");  
                sb.append(columns[i + 1]);  
                if (i + 2 < length) {  
                     // Append comma only if this isn't the last column  
                     sb.append(", ");  
                }  
           }  
           sb.append(");");  
           // Create table  
           db.execSQL(sb.toString());  
      }  
      /**  
       * Drop table if exists in given database  
       *  
       * @param db    Reference to the underlying database  
       * @param tableName The table name of which we try to drop  
       */  
      public static void dropTable(SQLiteDatabase db, String tableName) {  
           dropTable(db, new StringBuilder(), tableName);  
      }  
      /**  
       * Drop table if exists in given database  
       *  
       * @param db    Reference to the underlying database  
       * @param sb    Clears any existing values before starting to append new values  
       * @param tableName The table name of which we try to drop  
       */  
      public static void dropTable(SQLiteDatabase db, StringBuilder sb, String tableName) {  
           StringUtils.clearBuffer(sb);  
           sb.append("DROP TABLE IF EXISTS ");  
           sb.append(tableName);  
           // Drop table  
           db.execSQL(sb.toString());  
      }  
      /**  
       * Stores events and their lectures and speakers in db  
       * @param db - Writeable SQLITE DB  
       * @param events - events to be stored  
       * @return  
       */  
      public static boolean storeEvents(SQLiteDatabase db, List<Event> events) {  
           db.beginTransaction();  
           ContentValues cv;  
           List<Lecture> lectures;  
           List<Speaker> speakers;  
           long eventId;  
           for (Event event : events) {  
                //store event  
                cv = event.getContentValues();  
                db.replace(Event.TABLE_NAME, null, cv);  
                eventId = event.getId();  
                //loop through all lectures  
                lectures = event.getLectures();  
                for (Lecture lecture : lectures) {  
                     //set event id  
                     lecture.setEventId(eventId);  
                     cv = lecture.getContentValues();  
                     db.replace(Lecture.TABLE_NAME, null, cv);  
                     //remove all speakers from this lecture  
                     clearLectureSpeakers(db, lecture);  
                     //loop through all the speakers  
                     speakers = lecture.getSpeakers();  
                     for (Speaker speaker : speakers) {  
                          //store speaker in db  
                          cv = speaker.getContentValues();  
                          db.replace(Speaker.TABLE_NAME, null, cv);  
                          //add speaker to this lecture  
                          addSpeakerToLecture(db, speaker, lecture);  
                     }  
                }  
           }  
           db.setTransactionSuccessful();  
           db.endTransaction();  
           return true;  
      }  
 /**  
       * Fetch all events from DB  
       * @param db  
       * @return cursor holding id, name, description and logo url  
       */  
      public static Cursor getEventsCurosr(SQLiteDatabase db) {  
           String[] cols = new String[] {  
                     Event.COLUMN_NAME_ID,  
                     Event.COLUMN_NAME_NAME,  
                     Event.COLUMN_NAME_DESCRIPTION,  
                     Event.COLUMN_NAME_LOGO_URL  
           };  
           Cursor c;  
           c = db.query(Event.TABLE_NAME, cols, null, null, null, null, Event.COLUMN_NAME_START_DATE + " DESC");  
           return c;  
      }  
 {  

כמו שניתן לראות אנחנו מימשנו כמה פעולות:

1. יצירת טבלה.
2. מחיקת טבלה.
3. שמירת רשימה של אובייקטים מסוג Event בטבלה של sqlite.
4. מציאת הסמן של מיקום בטבלה (הסמן יכיל את מספר הזהות של האובייקט עליו הוא מצביע, כמו גם את שמו, תיאורו וה-URL לתמונה אותה הוא מחזיק) בשינוי קל מאוד נשתמש במתודה הזו ע"מ לחפש בטבלאות ה-sqlite ע"פ כל אחד מן העמודות בטבלה.

ו...זהו למעשה סיימנו להגדיר את ה-ContentProvider שלנו על כל חלקיו ויש לנו מנגנון גמיש ויעיל לשמירת המידע ולחיפוש בו, דוגמת שימוש תוכלו למצוא בפוסטים קודמים או בקוד המלא שקישור אליו מופיע למטה.

אני רוצה להודות שוב ל- +Ran Nachmany ו- +Amir Lazarovich אשר רוב הקוד שראיתם הוא שלהם ולהפנות אתכם לקוד המקור המלא של AndConLab כאן: https://github.com/RanNachmany/AndconLab

חוצמזה אני אשמח להשתמש בבמה הזו ע"מ להזמין אתכם להצטרף לרשת קבוצות ה-GDG שיש לנו ברחבי הארץ:

• http://www.meetup.com/GDG-Herzeliya/
• http://www.meetup.com/GDG-Tel-Aviv/
• http://www.meetup.com/GDG-Beer-Sheva/
• http://www.meetup.com/GDG-Haifa/
• חברי GDG נצרת! אנא שלחו לי קישור :)