1e40f9705244d454e82a8d4145e7788222f5de56
[PrivacyBrowser.git] / app / src / main / java / com / stoutner / privacybrowser / helpers / DomainsDatabaseHelper.java
1 /*
2  * Copyright © 2017-2019 Soren Stoutner <soren@stoutner.com>.
3  *
4  * This file is part of Privacy Browser <https://www.stoutner.com/privacy-browser>.
5  *
6  * Privacy Browser is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * Privacy Browser is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with Privacy Browser.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 package com.stoutner.privacybrowser.helpers;
21
22 import android.content.ContentValues;
23 import android.content.Context;
24 import android.content.SharedPreferences;
25 import android.database.Cursor;
26 import android.database.sqlite.SQLiteDatabase;
27 import android.database.sqlite.SQLiteOpenHelper;
28 import android.preference.PreferenceManager;
29
30 public class DomainsDatabaseHelper extends SQLiteOpenHelper {
31     private static final int SCHEMA_VERSION = 11;
32     static final String DOMAINS_DATABASE = "domains.db";
33     static final String DOMAINS_TABLE = "domains";
34
35     public static final String _ID = "_id";
36     public static final String DOMAIN_NAME = "domainname";
37     public static final String ENABLE_JAVASCRIPT = "enablejavascript";
38     public static final String ENABLE_FIRST_PARTY_COOKIES = "enablefirstpartycookies";
39     public static final String ENABLE_THIRD_PARTY_COOKIES = "enablethirdpartycookies";
40     public static final String ENABLE_DOM_STORAGE = "enabledomstorage";
41     public static final String ENABLE_FORM_DATA = "enableformdata";  // Form data can be removed once the minimum API >= 26.
42     public static final String ENABLE_EASYLIST = "enableeasylist";
43     public static final String ENABLE_EASYPRIVACY = "enableeasyprivacy";
44     public static final String ENABLE_FANBOYS_ANNOYANCE_LIST = "enablefanboysannoyancelist";
45     public static final String ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST = "enablefanboyssocialblockinglist";
46     public static final String ULTRALIST = "ultralist";
47     public static final String ENABLE_ULTRAPRIVACY = "enableultraprivacy";
48     public static final String BLOCK_ALL_THIRD_PARTY_REQUESTS = "blockallthirdpartyrequests";
49     public static final String USER_AGENT = "useragent";
50     public static final String FONT_SIZE = "fontsize";
51     public static final String SWIPE_TO_REFRESH = "swipetorefresh";
52     public static final String NIGHT_MODE = "nightmode";
53     public static final String WIDE_VIEWPORT = "wide_viewport";
54     public static final String DISPLAY_IMAGES = "displayimages";
55     public static final String PINNED_SSL_CERTIFICATE = "pinnedsslcertificate";
56     public static final String SSL_ISSUED_TO_COMMON_NAME = "sslissuedtocommonname";
57     public static final String SSL_ISSUED_TO_ORGANIZATION = "sslissuedtoorganization";
58     public static final String SSL_ISSUED_TO_ORGANIZATIONAL_UNIT = "sslissuedtoorganizationalunit";
59     public static final String SSL_ISSUED_BY_COMMON_NAME = "sslissuedbycommonname";
60     public static final String SSL_ISSUED_BY_ORGANIZATION = "sslissuedbyorganization";
61     public static final String SSL_ISSUED_BY_ORGANIZATIONAL_UNIT = "sslissuedbyorganizationalunit";
62     public static final String SSL_START_DATE = "sslstartdate";
63     public static final String SSL_END_DATE = "sslenddate";
64     public static final String PINNED_IP_ADDRESSES = "pinned_ip_addresses";
65     public static final String IP_ADDRESSES = "ip_addresses";
66
67     // Spinner constants.
68     public static final int SYSTEM_DEFAULT = 0;
69     public static final int ENABLED = 1;
70     public static final int DISABLED = 2;
71
72     static final String CREATE_DOMAINS_TABLE = "CREATE TABLE " + DOMAINS_TABLE + " (" +
73             _ID + " INTEGER PRIMARY KEY, " +
74             DOMAIN_NAME + " TEXT, " +
75             ENABLE_JAVASCRIPT + " BOOLEAN, " +
76             ENABLE_FIRST_PARTY_COOKIES + " BOOLEAN, " +
77             ENABLE_THIRD_PARTY_COOKIES + " BOOLEAN, " +
78             ENABLE_DOM_STORAGE + " BOOLEAN, " +
79             ENABLE_FORM_DATA + " BOOLEAN, " +
80             ENABLE_EASYLIST + " BOOLEAN, " +
81             ENABLE_EASYPRIVACY + " BOOLEAN, " +
82             ENABLE_FANBOYS_ANNOYANCE_LIST + " BOOLEAN, " +
83             ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST + " BOOLEAN, " +
84             ULTRALIST + " BOOLEAN, " +
85             ENABLE_ULTRAPRIVACY + " BOOLEAN, " +
86             BLOCK_ALL_THIRD_PARTY_REQUESTS + " BOOLEAN, " +
87             USER_AGENT + " TEXT, " +
88             FONT_SIZE + " INTEGER, " +
89             SWIPE_TO_REFRESH + " INTEGER, " +
90             NIGHT_MODE + " INTEGER, " +
91             WIDE_VIEWPORT + " INTEGER, " +
92             DISPLAY_IMAGES + " INTEGER, " +
93             PINNED_SSL_CERTIFICATE + " BOOLEAN, " +
94             SSL_ISSUED_TO_COMMON_NAME + " TEXT, " +
95             SSL_ISSUED_TO_ORGANIZATION + " TEXT, " +
96             SSL_ISSUED_TO_ORGANIZATIONAL_UNIT + " TEXT, " +
97             SSL_ISSUED_BY_COMMON_NAME + " TEXT, " +
98             SSL_ISSUED_BY_ORGANIZATION + " TEXT, " +
99             SSL_ISSUED_BY_ORGANIZATIONAL_UNIT + " TEXT, " +
100             SSL_START_DATE + " INTEGER, " +
101             SSL_END_DATE + " INTEGER, " +
102             PINNED_IP_ADDRESSES + " BOOLEAN, " +
103             IP_ADDRESSES + " TEXT)";
104
105     private final Context appContext;
106
107     // Initialize the database.  The lint warnings for the unused parameters are suppressed.
108     public DomainsDatabaseHelper(Context context, @SuppressWarnings("UnusedParameters") String name, SQLiteDatabase.CursorFactory cursorFactory, @SuppressWarnings("UnusedParameters") int version) {
109         super(context, DOMAINS_DATABASE, cursorFactory, SCHEMA_VERSION);
110
111         // Store a handle for the context.
112         appContext = context;
113     }
114
115     @Override
116     public void onCreate(SQLiteDatabase domainsDatabase) {
117         // Create the domains table.
118         domainsDatabase.execSQL(CREATE_DOMAINS_TABLE);
119     }
120
121     @Override
122     public void onUpgrade(SQLiteDatabase domainsDatabase, int oldVersion, int newVersion) {
123         // Upgrade the database table.
124         switch (oldVersion) {
125             // Upgrade from schema version 1.
126             case 1:
127                 // Add the display images column.
128                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + DISPLAY_IMAGES + " INTEGER");
129
130             // Upgrade from schema version 2.
131             case 2:
132                 //  Add the SSL certificate columns.
133                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + PINNED_SSL_CERTIFICATE + " BOOLEAN");
134                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_ISSUED_TO_COMMON_NAME + " TEXT");
135                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_ISSUED_TO_ORGANIZATION + " TEXT");
136                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_ISSUED_TO_ORGANIZATIONAL_UNIT + " TEXT");
137                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_ISSUED_BY_COMMON_NAME + " TEXT");
138                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_ISSUED_BY_ORGANIZATION + " TEXT");
139                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_ISSUED_BY_ORGANIZATIONAL_UNIT + " TEXT");
140                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_START_DATE + " INTEGER");
141                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SSL_END_DATE + " INTEGER");
142
143             // Upgrade from schema version 3.
144             case 3:
145                 // Add the Night Mode column.
146                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + NIGHT_MODE + " INTEGER");
147
148             // Upgrade from schema version 4.
149             case 4:
150                 // Add the block lists columns.
151                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + ENABLE_EASYLIST + " BOOLEAN");
152                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + ENABLE_EASYPRIVACY + " BOOLEAN");
153                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + ENABLE_FANBOYS_ANNOYANCE_LIST + " BOOLEAN");
154                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST + " BOOLEAN");
155
156                 // Get a handle for the shared preference.
157                 SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(appContext);
158
159                 // Get the default block list settings.
160                 boolean easyListEnabled = sharedPreferences.getBoolean("easylist", true);
161                 boolean easyPrivacyEnabled = sharedPreferences.getBoolean("easyprivacy", true);
162                 boolean fanboyAnnoyanceListEnabled = sharedPreferences.getBoolean("fanboys_annoyance_list", true);
163                 boolean fanboySocialBlockingListEnabled = sharedPreferences.getBoolean("fanboys_social_blocking_list", true);
164
165                 // Set EasyList for existing rows according to the current system-wide default.
166                 if (easyListEnabled) {
167                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_EASYLIST + " = " + 1);
168                 } else {
169                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_EASYLIST + " = " + 0);
170                 }
171
172                 // Set EasyPrivacy for existing rows according to the current system-wide default.
173                 if (easyPrivacyEnabled) {
174                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_EASYPRIVACY + " = " + 1);
175                 } else {
176                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_EASYPRIVACY + " = " + 0);
177                 }
178
179                 // Set Fanboy's Annoyance List for existing rows according to the current system-wide default.
180                 if (fanboyAnnoyanceListEnabled) {
181                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_FANBOYS_ANNOYANCE_LIST + " = " + 1);
182                 } else {
183                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_FANBOYS_ANNOYANCE_LIST + " = " + 0);
184                 }
185
186                 // Set Fanboy's Social Blocking List for existing rows according to the current system-wide default.
187                 if (fanboySocialBlockingListEnabled) {
188                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST + " = " + 1);
189                 } else {
190                     domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST + " = " + 0);
191                 }
192
193             // Upgrade from schema version 5.
194             case 5:
195                 // Add the swipe to refresh column.
196                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + SWIPE_TO_REFRESH + " INTEGER");
197
198             // Upgrade from schema version 6.
199             case 6:
200                 // Add the block all third-party requests column.
201                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + BLOCK_ALL_THIRD_PARTY_REQUESTS + " BOOLEAN");
202
203             // Upgrade from schema version 7.
204             case 7:
205                 // Add the UltraPrivacy column.
206                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + ENABLE_ULTRAPRIVACY + " BOOLEAN");
207
208                 // Enable it for all existing rows.
209                 domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ENABLE_ULTRAPRIVACY + " = " + 1);
210
211             // Upgrade from schema version 8.
212             case 8:
213                 // Add the Pinned IP Addresses columns.
214                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + PINNED_IP_ADDRESSES + " BOOLEAN");
215                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + IP_ADDRESSES + " TEXT");
216
217             // Upgrade from schema version 9.
218             case 9:
219                 // Add the Wide Viewport column.
220                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + WIDE_VIEWPORT + " INTEGER");
221
222             // Upgrade from schema version 10.
223             case 10:
224                 // Add the UltraList column.
225                 domainsDatabase.execSQL("ALTER TABLE " + DOMAINS_TABLE + " ADD COLUMN " + ULTRALIST + " BOOLEAN");
226
227                 // Enable it for all existing rows.
228                 domainsDatabase.execSQL("UPDATE " + DOMAINS_TABLE + " SET " + ULTRALIST + " = " + 1);
229         }
230     }
231
232     Cursor getCompleteCursorOrderedByDomain() {
233         // Get a readable database handle.
234         SQLiteDatabase domainsDatabase = this.getReadableDatabase();
235
236         // Return everything in the domains table ordered by the domain name.  The second argument is `null` because there are no `selectionArgs`.
237         return domainsDatabase.rawQuery("SELECT * FROM " + DOMAINS_TABLE + " ORDER BY " + DOMAIN_NAME + " ASC", null);
238     }
239
240     public Cursor getDomainNameCursorOrderedByDomain() {
241         // Get a readable database handle.
242         SQLiteDatabase domainsDatabase = this.getReadableDatabase();
243
244         // Get everything in the domains table ordered by the domain name.
245         String GET_CURSOR_ORDERED_BY_DOMAIN = "SELECT " + _ID + ", " + DOMAIN_NAME +
246                 " FROM " + DOMAINS_TABLE +
247                 " ORDER BY " + DOMAIN_NAME + " ASC";
248
249         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.  The cursor can't be closed because it is needed in the calling activity.
250         return domainsDatabase.rawQuery(GET_CURSOR_ORDERED_BY_DOMAIN, null);
251     }
252
253     public Cursor getDomainNameCursorOrderedByDomainExcept(int databaseId) {
254         // Get a readable database handle.
255         SQLiteDatabase domainsDatabase = this.getReadableDatabase();
256
257         // Prepare the SQL statement to select all rows except that with `databaseId`.
258         String GET_CURSOR_ORDERED_BY_DOMAIN_EXCEPT = "SELECT " + _ID + ", " + DOMAIN_NAME +
259                 " FROM " + DOMAINS_TABLE +
260                 " WHERE " + _ID + " IS NOT " + databaseId +
261                 " ORDER BY " + DOMAIN_NAME + " ASC";
262
263         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.  The cursor can't be closed because it is needed in the calling activity.
264         return domainsDatabase.rawQuery(GET_CURSOR_ORDERED_BY_DOMAIN_EXCEPT, null);
265     }
266
267     public Cursor getCursorForId(int databaseId) {
268         // Get a readable database handle.
269         SQLiteDatabase domainsDatabase = this.getReadableDatabase();
270
271         // Prepare the SQL statement to get the `Cursor` for `databaseId`.
272         String GET_CURSOR_FOR_ID = "SELECT * FROM " + DOMAINS_TABLE +
273                 " WHERE " + _ID + " = " + databaseId;
274
275         // Return the results as a `Cursor`.  The second argument is `null` because there are no `selectionArgs`.  The cursor can't be closed because it is needed in the calling activity.
276         return domainsDatabase.rawQuery(GET_CURSOR_FOR_ID, null);
277     }
278
279     public Cursor getCursorForDomainName(String domainName) {
280         // Get a readable database handle.
281         SQLiteDatabase domainsDatabase = this.getReadableDatabase();
282
283         // Return a cursor for the requested domain name.
284         return domainsDatabase.query(DOMAINS_TABLE, null, DOMAIN_NAME + " = " + "\"" + domainName + "\"", null, null, null, null);
285
286     }
287
288     public int addDomain(String domainName) {
289         // Store the domain data in a `ContentValues`.
290         ContentValues domainContentValues = new ContentValues();
291
292         // Get a handle for the shared preference.
293         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(appContext);
294
295         // Get the default settings.
296         boolean javaScript = sharedPreferences.getBoolean("javascript", false);
297         boolean firstPartyCookies = sharedPreferences.getBoolean("first_party_cookies", false);
298         boolean thirdPartyCookies = sharedPreferences.getBoolean("third_party_cookies", false);
299         boolean domStorage = sharedPreferences.getBoolean("dom_storage", false);
300         boolean saveFormData = sharedPreferences.getBoolean("save_form_data", false);  // Form data can be removed once the minimum API >= 26.
301         boolean easyList = sharedPreferences.getBoolean("easylist", true);
302         boolean easyPrivacy = sharedPreferences.getBoolean("easyprivacy", true);
303         boolean fanboyAnnoyanceList = sharedPreferences.getBoolean("fanboys_annoyance_list", true);
304         boolean fanboySocialBlockingList = sharedPreferences.getBoolean("fanboys_social_blocking_list", true);
305         boolean ultraList = sharedPreferences.getBoolean("ultralist", true);
306         boolean ultraPrivacy = sharedPreferences.getBoolean("ultraprivacy", true);
307         boolean blockAllThirdPartyRequests = sharedPreferences.getBoolean("block_all_third_party_requests", false);
308
309         // Create entries for the database fields.  The ID is created automatically.  The pinned SSL certificate information is not created unless added by the user.
310         domainContentValues.put(DOMAIN_NAME, domainName);
311         domainContentValues.put(ENABLE_JAVASCRIPT, javaScript);
312         domainContentValues.put(ENABLE_FIRST_PARTY_COOKIES, firstPartyCookies);
313         domainContentValues.put(ENABLE_THIRD_PARTY_COOKIES, thirdPartyCookies);
314         domainContentValues.put(ENABLE_DOM_STORAGE, domStorage);
315         domainContentValues.put(ENABLE_FORM_DATA, saveFormData);  // Form data can be removed once the minimum API >= 26.
316         domainContentValues.put(ENABLE_EASYLIST, easyList);
317         domainContentValues.put(ENABLE_EASYPRIVACY, easyPrivacy);
318         domainContentValues.put(ENABLE_FANBOYS_ANNOYANCE_LIST, fanboyAnnoyanceList);
319         domainContentValues.put(ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST, fanboySocialBlockingList);
320         domainContentValues.put(ULTRALIST, ultraList);
321         domainContentValues.put(ENABLE_ULTRAPRIVACY, ultraPrivacy);
322         domainContentValues.put(BLOCK_ALL_THIRD_PARTY_REQUESTS, blockAllThirdPartyRequests);
323         domainContentValues.put(USER_AGENT, "System default user agent");
324         domainContentValues.put(FONT_SIZE, 0);
325         domainContentValues.put(SWIPE_TO_REFRESH, 0);
326         domainContentValues.put(NIGHT_MODE, 0);
327         domainContentValues.put(WIDE_VIEWPORT, 0);
328         domainContentValues.put(DISPLAY_IMAGES, 0);
329
330         // Get a writable database handle.
331         SQLiteDatabase domainsDatabase = this.getWritableDatabase();
332
333         // Insert a new row and store the resulting database ID.  The second argument is `null`, which makes it so that a completely null row cannot be created.
334         int newDomainDatabaseId  = (int) domainsDatabase.insert(DOMAINS_TABLE, null, domainContentValues);
335
336         // Close the database handle.
337         domainsDatabase.close();
338
339         // Return the new domain database ID.
340         return newDomainDatabaseId;
341     }
342
343     void addDomain(ContentValues contentValues) {
344         // Get a writable database handle.
345         SQLiteDatabase domainsDatabase = this.getWritableDatabase();
346
347         // Add the new domain.
348         domainsDatabase.insert(DOMAINS_TABLE, null, contentValues);
349
350         // Close the database handle.
351         domainsDatabase.close();
352     }
353
354     public void updateDomain(int databaseId, String domainName, boolean javaScript, boolean firstPartyCookies, boolean thirdPartyCookies, boolean domStorage, boolean formData, boolean easyList,
355                              boolean easyPrivacy, boolean fanboysAnnoyance, boolean fanboysSocialBlocking, boolean ultraList, boolean ultraPrivacy, boolean blockAllThirdPartyRequests, String userAgent,
356                              int fontSize, int swipeToRefresh, int nightMode, int wideViewport, int displayImages, boolean pinnedSslCertificate, boolean pinnedIpAddresses) {
357
358         // Store the domain data in a `ContentValues`.
359         ContentValues domainContentValues = new ContentValues();
360
361         // Add entries for each field in the database.
362         domainContentValues.put(DOMAIN_NAME, domainName);
363         domainContentValues.put(ENABLE_JAVASCRIPT, javaScript);
364         domainContentValues.put(ENABLE_FIRST_PARTY_COOKIES, firstPartyCookies);
365         domainContentValues.put(ENABLE_THIRD_PARTY_COOKIES, thirdPartyCookies);
366         domainContentValues.put(ENABLE_DOM_STORAGE, domStorage);
367         domainContentValues.put(ENABLE_FORM_DATA, formData);  // Form data can be removed once the minimum API >= 26.
368         domainContentValues.put(ENABLE_EASYLIST, easyList);
369         domainContentValues.put(ENABLE_EASYPRIVACY, easyPrivacy);
370         domainContentValues.put(ENABLE_FANBOYS_ANNOYANCE_LIST, fanboysAnnoyance);
371         domainContentValues.put(ENABLE_FANBOYS_SOCIAL_BLOCKING_LIST, fanboysSocialBlocking);
372         domainContentValues.put(ULTRALIST, ultraList);
373         domainContentValues.put(ENABLE_ULTRAPRIVACY, ultraPrivacy);
374         domainContentValues.put(BLOCK_ALL_THIRD_PARTY_REQUESTS, blockAllThirdPartyRequests);
375         domainContentValues.put(USER_AGENT, userAgent);
376         domainContentValues.put(FONT_SIZE, fontSize);
377         domainContentValues.put(SWIPE_TO_REFRESH, swipeToRefresh);
378         domainContentValues.put(NIGHT_MODE, nightMode);
379         domainContentValues.put(WIDE_VIEWPORT, wideViewport);
380         domainContentValues.put(DISPLAY_IMAGES, displayImages);
381         domainContentValues.put(PINNED_SSL_CERTIFICATE, pinnedSslCertificate);
382         domainContentValues.put(PINNED_IP_ADDRESSES, pinnedIpAddresses);
383
384         // Get a writable database handle.
385         SQLiteDatabase domainsDatabase = this.getWritableDatabase();
386
387         // Update the row for `databaseId`.  The last argument is `null` because there are no `whereArgs`.
388         domainsDatabase.update(DOMAINS_TABLE, domainContentValues, _ID + " = " + databaseId, null);
389
390         // Close the database handle.
391         domainsDatabase.close();
392     }
393
394     public void updatePinnedSslCertificate(int databaseId, String sslIssuedToCommonName, String sslIssuedToOrganization, String sslIssuedToOrganizationalUnit, String sslIssuedByCommonName,
395                                      String sslIssuedByOrganization, String sslIssuedByOrganizationalUnit, long sslStartDate, long sslEndDate) {
396
397         // Store the pinned SSL certificate in a content values.
398         ContentValues pinnedSslCertificateContentValues = new ContentValues();
399
400         // Add entries for each field in the certificate.
401         pinnedSslCertificateContentValues.put(SSL_ISSUED_TO_COMMON_NAME, sslIssuedToCommonName);
402         pinnedSslCertificateContentValues.put(SSL_ISSUED_TO_ORGANIZATION, sslIssuedToOrganization);
403         pinnedSslCertificateContentValues.put(SSL_ISSUED_TO_ORGANIZATIONAL_UNIT, sslIssuedToOrganizationalUnit);
404         pinnedSslCertificateContentValues.put(SSL_ISSUED_BY_COMMON_NAME, sslIssuedByCommonName);
405         pinnedSslCertificateContentValues.put(SSL_ISSUED_BY_ORGANIZATION, sslIssuedByOrganization);
406         pinnedSslCertificateContentValues.put(SSL_ISSUED_BY_ORGANIZATIONAL_UNIT, sslIssuedByOrganizationalUnit);
407         pinnedSslCertificateContentValues.put(SSL_START_DATE, sslStartDate);
408         pinnedSslCertificateContentValues.put(SSL_END_DATE, sslEndDate);
409
410         // Get a writable database handle.
411         SQLiteDatabase domainsDatabase = this.getWritableDatabase();
412
413         // Update the row for database ID.
414         domainsDatabase.update(DOMAINS_TABLE, pinnedSslCertificateContentValues, _ID + " = " + databaseId, null);
415
416         // Close the database handle.
417         domainsDatabase.close();
418     }
419
420     public void updatePinnedIpAddresses(int databaseId, String ipAddresses) {
421         // Store the pinned IP addresses in a content values.
422         ContentValues pinnedIpAddressesContentValues = new ContentValues();
423
424         // Add the IP addresses to the content values.
425         pinnedIpAddressesContentValues.put(IP_ADDRESSES, ipAddresses);
426
427         // Get a writable database handle.
428         SQLiteDatabase domainsDatabase = this.getWritableDatabase();
429
430         // Update the row for the database ID.
431         domainsDatabase.update(DOMAINS_TABLE, pinnedIpAddressesContentValues, _ID + " = " + databaseId, null);
432
433         // Close the database handle.
434         domainsDatabase.close();
435     }
436
437     public void deleteDomain(int databaseId) {
438         // Get a writable database handle.
439         SQLiteDatabase domainsDatabase = this.getWritableDatabase();
440
441         // Delete the row for `databaseId`.  The last argument is `null` because we don't need additional parameters.
442         domainsDatabase.delete(DOMAINS_TABLE, _ID + " = " + databaseId, null);
443
444         // Close the database handle.
445         domainsDatabase.close();
446     }
447 }