blob: ad9a13eea0a75236da83e3ed8b880c7f7b860aed [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Daniel Sandler325dc232013-06-05 22:57:57 -040017package com.android.launcher3;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
The Android Open Source Project7376fae2009-03-11 12:11:58 -070019import android.appwidget.AppWidgetHost;
Mike Cleronb87bd162009-10-30 16:36:56 -070020import android.appwidget.AppWidgetManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080021import android.content.ComponentName;
Adam Cohen228da5a2011-07-27 22:23:47 -070022import android.content.ContentProvider;
Yura085c8532014-02-11 15:15:29 +000023import android.content.ContentProviderOperation;
24import android.content.ContentProviderResult;
Adam Cohen228da5a2011-07-27 22:23:47 -070025import android.content.ContentUris;
26import android.content.ContentValues;
27import android.content.Context;
28import android.content.Intent;
Yura085c8532014-02-11 15:15:29 +000029import android.content.OperationApplicationException;
Michael Jurkab85f8a42012-04-25 15:48:32 -070030import android.content.SharedPreferences;
Sunny Goyalb2d46ce2015-03-26 11:32:11 -070031import android.content.pm.PackageManager.NameNotFoundException;
Adam Cohen228da5a2011-07-27 22:23:47 -070032import android.content.res.Resources;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080033import android.database.Cursor;
34import android.database.SQLException;
Adam Cohen228da5a2011-07-27 22:23:47 -070035import android.database.sqlite.SQLiteDatabase;
36import android.database.sqlite.SQLiteOpenHelper;
37import android.database.sqlite.SQLiteQueryBuilder;
Sunny Goyal0b037782015-04-02 10:27:03 -070038import android.database.sqlite.SQLiteStatement;
Adam Cohen228da5a2011-07-27 22:23:47 -070039import android.net.Uri;
Sunny Goyal7779d622015-06-11 16:18:39 -070040import android.os.Binder;
Sunny Goyalb2d46ce2015-03-26 11:32:11 -070041import android.os.Bundle;
Sunny Goyalb5b55c82016-05-10 12:28:59 -070042import android.os.Handler;
43import android.os.Message;
Sunny Goyal7779d622015-06-11 16:18:39 -070044import android.os.Process;
Sunny Goyale26d1002016-06-20 14:52:14 -070045import android.os.Trace;
Sunny Goyal7c74e4a2016-12-15 15:53:17 -080046import android.os.UserHandle;
Sunny Goyalb2d46ce2015-03-26 11:32:11 -070047import android.os.UserManager;
Adam Cohen228da5a2011-07-27 22:23:47 -070048import android.text.TextUtils;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080049import android.util.Log;
Adam Cohen228da5a2011-07-27 22:23:47 -070050
Sunny Goyal0fe505b2014-08-06 09:55:36 -070051import com.android.launcher3.AutoInstallsLayout.LayoutParserCallback;
52import com.android.launcher3.LauncherSettings.Favorites;
Sunny Goyalb5b55c82016-05-10 12:28:59 -070053import com.android.launcher3.LauncherSettings.WorkspaceScreens;
Kenny Guyed131872014-04-30 03:02:21 +010054import com.android.launcher3.compat.UserManagerCompat;
Sunny Goyala9e2f5a2016-06-10 12:22:04 -070055import com.android.launcher3.config.FeatureFlags;
Chris Wrene523e702013-10-09 10:36:55 -040056import com.android.launcher3.config.ProviderConfig;
Tony Wickham827cef22016-03-17 15:39:39 -070057import com.android.launcher3.dynamicui.ExtractionUtils;
Sunny Goyalfdbef272017-02-01 12:52:54 -080058import com.android.launcher3.logging.FileLog;
Sunny Goyala9e2f5a2016-06-10 12:22:04 -070059import com.android.launcher3.provider.LauncherDbUtils;
Sunny Goyale8f7d5a2016-05-24 11:30:14 -070060import com.android.launcher3.provider.RestoreDbTask;
Sunny Goyale2fba6c2015-05-12 10:39:59 -070061import com.android.launcher3.util.ManagedProfileHeuristic;
Sunny Goyalbf67f3b2016-03-15 15:30:11 -070062import com.android.launcher3.util.NoLocaleSqliteContext;
Sunny Goyalb5b55c82016-05-10 12:28:59 -070063import com.android.launcher3.util.Preconditions;
Adam Cohen091440a2015-03-18 14:16:05 -070064import com.android.launcher3.util.Thunk;
Michael Jurka8b805b12012-04-18 14:23:14 -070065
Mike Cleronb87bd162009-10-30 16:36:56 -070066import java.net.URISyntaxException;
Adam Cohen228da5a2011-07-27 22:23:47 -070067import java.util.ArrayList;
Adam Cohen71483f42014-05-15 14:04:01 -070068import java.util.Collections;
Louis Begina9c21c62016-08-15 15:18:41 -070069import java.util.Locale;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080070
The Android Open Source Project31dd5032009-03-03 19:32:27 -080071public class LauncherProvider extends ContentProvider {
Sunny Goyalc74e4192015-09-08 14:01:03 -070072 private static final String TAG = "LauncherProvider";
Joe Onoratoa30ce8e2009-11-11 08:16:49 -080073 private static final boolean LOGD = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080074
Sunny Goyala9e2f5a2016-06-10 12:22:04 -070075 private static final int DATABASE_VERSION = 27;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080076
Sunny Goyale5bb7052015-07-27 14:36:07 -070077 public static final String AUTHORITY = ProviderConfig.AUTHORITY;
Winson Chung3d503fb2011-07-13 17:25:49 -070078
Sunny Goyale87e6ab2014-11-21 22:42:53 -080079 static final String EMPTY_DATABASE_CREATED = "EMPTY_DATABASE_CREATED";
The Android Open Source Project31dd5032009-03-03 19:32:27 -080080
Sunny Goyalb2d46ce2015-03-26 11:32:11 -070081 private static final String RESTRICTION_PACKAGE_NAME = "workspace.configuration.package.name";
82
Sunny Goyalb5b55c82016-05-10 12:28:59 -070083 private final ChangeListenerWrapper mListenerWrapper = new ChangeListenerWrapper();
84 private Handler mListenerHandler;
85
Sunny Goyalf076eae2016-01-11 12:25:10 -080086 protected DatabaseHelper mOpenHelper;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080087
88 @Override
89 public boolean onCreate() {
Sunny Goyale26d1002016-06-20 14:52:14 -070090 if (ProviderConfig.IS_DOGFOOD_BUILD) {
91 Log.d(TAG, "Launcher process started");
92 }
Sunny Goyalb5b55c82016-05-10 12:28:59 -070093 mListenerHandler = new Handler(mListenerWrapper);
94
Sunny Goyalfdbef272017-02-01 12:52:54 -080095 // The content provider exists for the entire duration of the launcher main process and
96 // is the first component to get created. Initializing FileLog here ensures that it's
97 // always available in the main process.
98 FileLog.setDir(getContext().getApplicationContext().getFilesDir());
The Android Open Source Project31dd5032009-03-03 19:32:27 -080099 return true;
100 }
101
Sunny Goyald3849d12015-10-29 10:28:32 -0700102 /**
103 * Sets a provider listener.
104 */
Anjali Koppal67e7cae2014-03-13 12:14:12 -0700105 public void setLauncherProviderChangeListener(LauncherProviderChangeListener listener) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700106 Preconditions.assertUIThread();
107 mListenerWrapper.mListener = listener;
Anjali Koppal67e7cae2014-03-13 12:14:12 -0700108 }
109
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800110 @Override
111 public String getType(Uri uri) {
112 SqlArguments args = new SqlArguments(uri, null, null);
113 if (TextUtils.isEmpty(args.where)) {
114 return "vnd.android.cursor.dir/" + args.table;
115 } else {
116 return "vnd.android.cursor.item/" + args.table;
117 }
118 }
119
Sunny Goyalf076eae2016-01-11 12:25:10 -0800120 /**
121 * Overridden in tests
122 */
123 protected synchronized void createDbIfNotExists() {
Sunny Goyald3849d12015-10-29 10:28:32 -0700124 if (mOpenHelper == null) {
Sunny Goyale26d1002016-06-20 14:52:14 -0700125 if (LauncherAppState.PROFILE_STARTUP) {
126 Trace.beginSection("Opening workspace DB");
127 }
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700128 mOpenHelper = new DatabaseHelper(getContext(), mListenerHandler);
Sunny Goyale8f7d5a2016-05-24 11:30:14 -0700129
130 if (RestoreDbTask.isPending(getContext())) {
131 if (!RestoreDbTask.performRestore(mOpenHelper)) {
132 mOpenHelper.createEmptyDB(mOpenHelper.getWritableDatabase());
133 }
134 // Set is pending to false irrespective of the result, so that it doesn't get
135 // executed again.
136 RestoreDbTask.setPending(getContext(), false);
137 }
Sunny Goyale26d1002016-06-20 14:52:14 -0700138
139 if (LauncherAppState.PROFILE_STARTUP) {
140 Trace.endSection();
141 }
Sunny Goyald3849d12015-10-29 10:28:32 -0700142 }
143 }
144
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800145 @Override
146 public Cursor query(Uri uri, String[] projection, String selection,
147 String[] selectionArgs, String sortOrder) {
Sunny Goyald3849d12015-10-29 10:28:32 -0700148 createDbIfNotExists();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800149
150 SqlArguments args = new SqlArguments(uri, selection, selectionArgs);
151 SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
152 qb.setTables(args.table);
153
Romain Guy73b979d2009-06-09 12:57:21 -0700154 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800155 Cursor result = qb.query(db, projection, args.where, args.args, null, null, sortOrder);
156 result.setNotificationUri(getContext().getContentResolver(), uri);
157
158 return result;
159 }
160
Adam Cohen091440a2015-03-18 14:16:05 -0700161 @Thunk static long dbInsertAndCheck(DatabaseHelper helper,
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700162 SQLiteDatabase db, String table, String nullColumnHack, ContentValues values) {
Dan Sandlerd5024042014-01-09 15:01:33 -0500163 if (values == null) {
164 throw new RuntimeException("Error: attempting to insert null values");
165 }
Adam Cohen71483f42014-05-15 14:04:01 -0700166 if (!values.containsKey(LauncherSettings.ChangeLogColumns._ID)) {
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700167 throw new RuntimeException("Error: attempting to add item without specifying an id");
168 }
Chris Wren5dee7af2013-12-20 17:22:11 -0500169 helper.checkId(table, values);
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700170 return db.insert(table, nullColumnHack, values);
171 }
172
Sunny Goyald1064182015-08-13 12:08:30 -0700173 private void reloadLauncherIfExternal() {
Sunny Goyalc74e4192015-09-08 14:01:03 -0700174 if (Utilities.ATLEAST_MARSHMALLOW && Binder.getCallingPid() != Process.myPid()) {
Sunny Goyald1064182015-08-13 12:08:30 -0700175 LauncherAppState app = LauncherAppState.getInstanceNoCreate();
176 if (app != null) {
Sunny Goyaldd96a5e2017-02-17 11:22:34 -0800177 app.getModel().forceReload();
Sunny Goyald1064182015-08-13 12:08:30 -0700178 }
179 }
180 }
181
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800182 @Override
183 public Uri insert(Uri uri, ContentValues initialValues) {
Sunny Goyald3849d12015-10-29 10:28:32 -0700184 createDbIfNotExists();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800185 SqlArguments args = new SqlArguments(uri);
186
Sunny Goyald1064182015-08-13 12:08:30 -0700187 // In very limited cases, we support system|signature permission apps to modify the db.
188 if (Binder.getCallingPid() != Process.myPid()) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700189 if (!initializeExternalAdd(initialValues)) {
Adam Cohena043fa82014-07-23 14:49:38 -0700190 return null;
191 }
192 }
193
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800194 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
Chris Wren1ada10d2013-09-13 18:01:38 -0400195 addModifiedTime(initialValues);
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700196 final long rowId = dbInsertAndCheck(mOpenHelper, db, args.table, null, initialValues);
Sunny Goyale72f3d52015-03-02 14:24:21 -0800197 if (rowId < 0) return null;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800198
199 uri = ContentUris.withAppendedId(uri, rowId);
Sunny Goyal1d4a2df2015-03-30 11:11:46 -0700200 notifyListeners();
201
Sunny Goyalc74e4192015-09-08 14:01:03 -0700202 if (Utilities.ATLEAST_MARSHMALLOW) {
203 reloadLauncherIfExternal();
204 } else {
205 // Deprecated behavior to support legacy devices which rely on provider callbacks.
206 LauncherAppState app = LauncherAppState.getInstanceNoCreate();
207 if (app != null && "true".equals(uri.getQueryParameter("isExternalAdd"))) {
Sunny Goyaldd96a5e2017-02-17 11:22:34 -0800208 app.getModel().forceReload();
Sunny Goyalc74e4192015-09-08 14:01:03 -0700209 }
210
211 String notify = uri.getQueryParameter("notify");
212 if (notify == null || "true".equals(notify)) {
213 getContext().getContentResolver().notifyChange(uri, null);
214 }
215 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800216 return uri;
217 }
218
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700219 private boolean initializeExternalAdd(ContentValues values) {
220 // 1. Ensure that externally added items have a valid item id
221 long id = mOpenHelper.generateNewItemId();
222 values.put(LauncherSettings.Favorites._ID, id);
223
224 // 2. In the case of an app widget, and if no app widget id is specified, we
225 // attempt allocate and bind the widget.
226 Integer itemType = values.getAsInteger(LauncherSettings.Favorites.ITEM_TYPE);
227 if (itemType != null &&
228 itemType.intValue() == LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET &&
229 !values.containsKey(LauncherSettings.Favorites.APPWIDGET_ID)) {
230
231 final AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(getContext());
232 ComponentName cn = ComponentName.unflattenFromString(
233 values.getAsString(Favorites.APPWIDGET_PROVIDER));
234
235 if (cn != null) {
236 try {
237 int appWidgetId = new AppWidgetHost(getContext(), Launcher.APPWIDGET_HOST_ID)
238 .allocateAppWidgetId();
239 values.put(LauncherSettings.Favorites.APPWIDGET_ID, appWidgetId);
240 if (!appWidgetManager.bindAppWidgetIdIfAllowed(appWidgetId,cn)) {
241 return false;
242 }
243 } catch (RuntimeException e) {
244 Log.e(TAG, "Failed to initialize external widget", e);
245 return false;
246 }
247 } else {
248 return false;
249 }
250 }
251
252 // Add screen id if not present
253 long screenId = values.getAsLong(LauncherSettings.Favorites.SCREEN);
254 SQLiteStatement stmp = null;
255 try {
256 stmp = mOpenHelper.getWritableDatabase().compileStatement(
257 "INSERT OR IGNORE INTO workspaceScreens (_id, screenRank) " +
258 "select ?, (ifnull(MAX(screenRank), -1)+1) from workspaceScreens");
259 stmp.bindLong(1, screenId);
260
261 ContentValues valuesInserted = new ContentValues();
262 valuesInserted.put(LauncherSettings.BaseLauncherColumns._ID, stmp.executeInsert());
263 mOpenHelper.checkId(WorkspaceScreens.TABLE_NAME, valuesInserted);
264 return true;
265 } catch (Exception e) {
266 return false;
267 } finally {
268 Utilities.closeSilently(stmp);
269 }
270 }
271
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800272 @Override
273 public int bulkInsert(Uri uri, ContentValues[] values) {
Sunny Goyald3849d12015-10-29 10:28:32 -0700274 createDbIfNotExists();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800275 SqlArguments args = new SqlArguments(uri);
276
277 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
278 db.beginTransaction();
279 try {
280 int numValues = values.length;
281 for (int i = 0; i < numValues; i++) {
Chris Wren1ada10d2013-09-13 18:01:38 -0400282 addModifiedTime(values[i]);
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700283 if (dbInsertAndCheck(mOpenHelper, db, args.table, null, values[i]) < 0) {
284 return 0;
285 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800286 }
287 db.setTransactionSuccessful();
288 } finally {
289 db.endTransaction();
290 }
291
Sunny Goyal1d4a2df2015-03-30 11:11:46 -0700292 notifyListeners();
Sunny Goyald1064182015-08-13 12:08:30 -0700293 reloadLauncherIfExternal();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800294 return values.length;
295 }
296
297 @Override
Yura085c8532014-02-11 15:15:29 +0000298 public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
299 throws OperationApplicationException {
Sunny Goyald3849d12015-10-29 10:28:32 -0700300 createDbIfNotExists();
Yura085c8532014-02-11 15:15:29 +0000301 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
302 db.beginTransaction();
303 try {
304 ContentProviderResult[] result = super.applyBatch(operations);
305 db.setTransactionSuccessful();
Sunny Goyald1064182015-08-13 12:08:30 -0700306 reloadLauncherIfExternal();
Yura085c8532014-02-11 15:15:29 +0000307 return result;
308 } finally {
309 db.endTransaction();
310 }
311 }
312
313 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800314 public int delete(Uri uri, String selection, String[] selectionArgs) {
Sunny Goyald3849d12015-10-29 10:28:32 -0700315 createDbIfNotExists();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800316 SqlArguments args = new SqlArguments(uri, selection, selectionArgs);
317
318 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800319
Louis Begina9c21c62016-08-15 15:18:41 -0700320 if (Binder.getCallingPid() != Process.myPid()
321 && Favorites.TABLE_NAME.equalsIgnoreCase(args.table)) {
322 String widgetSelection = TextUtils.isEmpty(args.where) ? "1=1" : args.where;
323 widgetSelection = String.format(Locale.ENGLISH, "%1$s = %2$d AND ( %3$s )",
324 Favorites.ITEM_TYPE, Favorites.ITEM_TYPE_APPWIDGET, widgetSelection);
325 try (Cursor c = db.query(Favorites.TABLE_NAME, new String[] { Favorites.APPWIDGET_ID },
326 widgetSelection, args.args, null, null, null)) {
327 AppWidgetHost host = new AppWidgetHost(getContext(), Launcher.APPWIDGET_HOST_ID);
328 while (c.moveToNext()) {
329 int widgetId = c.getInt(0);
330 if (widgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
331 try {
332 host.deleteAppWidgetId(widgetId);
333 } catch (RuntimeException e) {
334 Log.e(TAG, "Error deleting widget id " + widgetId, e);
335 }
336 }
337 }
338 }
339 }
340 int count = db.delete(args.table, args.where, args.args);
341 if (count > 0) {
342 notifyListeners();
343 reloadLauncherIfExternal();
344 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800345 return count;
346 }
347
348 @Override
349 public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
Sunny Goyald3849d12015-10-29 10:28:32 -0700350 createDbIfNotExists();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800351 SqlArguments args = new SqlArguments(uri, selection, selectionArgs);
352
Chris Wren1ada10d2013-09-13 18:01:38 -0400353 addModifiedTime(values);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800354 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
355 int count = db.update(args.table, values, args.where, args.args);
Sunny Goyal1d4a2df2015-03-30 11:11:46 -0700356 if (count > 0) notifyListeners();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800357
Sunny Goyald1064182015-08-13 12:08:30 -0700358 reloadLauncherIfExternal();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800359 return count;
360 }
361
Sunny Goyal7779d622015-06-11 16:18:39 -0700362 @Override
Tony Wickham827cef22016-03-17 15:39:39 -0700363 public Bundle call(String method, final String arg, final Bundle extras) {
Sunny Goyal7779d622015-06-11 16:18:39 -0700364 if (Binder.getCallingUid() != Process.myUid()) {
365 return null;
366 }
Sunny Goyald3849d12015-10-29 10:28:32 -0700367 createDbIfNotExists();
Sunny Goyal7779d622015-06-11 16:18:39 -0700368
369 switch (method) {
Tony Wickham827cef22016-03-17 15:39:39 -0700370 case LauncherSettings.Settings.METHOD_SET_EXTRACTED_COLORS_AND_WALLPAPER_ID: {
371 String extractedColors = extras.getString(
372 LauncherSettings.Settings.EXTRA_EXTRACTED_COLORS);
373 int wallpaperId = extras.getInt(LauncherSettings.Settings.EXTRA_WALLPAPER_ID);
374 Utilities.getPrefs(getContext()).edit()
375 .putString(ExtractionUtils.EXTRACTED_COLORS_PREFERENCE_KEY, extractedColors)
376 .putInt(ExtractionUtils.WALLPAPER_ID_PREFERENCE_KEY, wallpaperId)
377 .apply();
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700378 mListenerHandler.sendEmptyMessage(ChangeListenerWrapper.MSG_EXTRACTED_COLORS_CHANGED);
Tony Wickham827cef22016-03-17 15:39:39 -0700379 Bundle result = new Bundle();
380 result.putString(LauncherSettings.Settings.EXTRA_VALUE, extractedColors);
381 return result;
382 }
Sunny Goyald2497482015-09-22 18:24:19 -0700383 case LauncherSettings.Settings.METHOD_CLEAR_EMPTY_DB_FLAG: {
384 clearFlagEmptyDbCreated();
385 return null;
386 }
Sunny Goyala5c8a9e2016-07-08 08:32:44 -0700387 case LauncherSettings.Settings.METHOD_WAS_EMPTY_DB_CREATED : {
388 Bundle result = new Bundle();
389 result.putBoolean(LauncherSettings.Settings.EXTRA_VALUE,
390 Utilities.getPrefs(getContext()).getBoolean(EMPTY_DATABASE_CREATED, false));
391 return result;
392 }
Sunny Goyald2497482015-09-22 18:24:19 -0700393 case LauncherSettings.Settings.METHOD_DELETE_EMPTY_FOLDERS: {
394 Bundle result = new Bundle();
395 result.putSerializable(LauncherSettings.Settings.EXTRA_VALUE, deleteEmptyFolders());
396 return result;
397 }
398 case LauncherSettings.Settings.METHOD_NEW_ITEM_ID: {
399 Bundle result = new Bundle();
400 result.putLong(LauncherSettings.Settings.EXTRA_VALUE, mOpenHelper.generateNewItemId());
401 return result;
402 }
403 case LauncherSettings.Settings.METHOD_NEW_SCREEN_ID: {
404 Bundle result = new Bundle();
405 result.putLong(LauncherSettings.Settings.EXTRA_VALUE, mOpenHelper.generateNewScreenId());
406 return result;
407 }
408 case LauncherSettings.Settings.METHOD_CREATE_EMPTY_DB: {
409 createEmptyDB();
410 return null;
411 }
412 case LauncherSettings.Settings.METHOD_LOAD_DEFAULT_FAVORITES: {
413 loadDefaultFavoritesIfNecessary();
414 return null;
415 }
Sunny Goyald2497482015-09-22 18:24:19 -0700416 case LauncherSettings.Settings.METHOD_DELETE_DB: {
Sunny Goyalaefc0c42015-12-10 17:46:12 -0800417 // Are you sure? (y/n)
418 mOpenHelper.createEmptyDB(mOpenHelper.getWritableDatabase());
Sunny Goyald2497482015-09-22 18:24:19 -0700419 return null;
420 }
Sunny Goyal7779d622015-06-11 16:18:39 -0700421 }
422 return null;
423 }
424
Sunny Goyalb1622cc2015-06-10 16:00:42 -0700425 /**
426 * Deletes any empty folder from the DB.
427 * @return Ids of deleted folders.
428 */
Sunny Goyald2497482015-09-22 18:24:19 -0700429 private ArrayList<Long> deleteEmptyFolders() {
430 ArrayList<Long> folderIds = new ArrayList<>();
Sunny Goyalb1622cc2015-06-10 16:00:42 -0700431 SQLiteDatabase db = mOpenHelper.getWritableDatabase();
432 db.beginTransaction();
433 try {
434 // Select folders whose id do not match any container value.
435 String selection = LauncherSettings.Favorites.ITEM_TYPE + " = "
436 + LauncherSettings.Favorites.ITEM_TYPE_FOLDER + " AND "
437 + LauncherSettings.Favorites._ID + " NOT IN (SELECT " +
438 LauncherSettings.Favorites.CONTAINER + " FROM "
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700439 + Favorites.TABLE_NAME + ")";
440 Cursor c = db.query(Favorites.TABLE_NAME,
Sunny Goyalb1622cc2015-06-10 16:00:42 -0700441 new String[] {LauncherSettings.Favorites._ID},
442 selection, null, null, null, null);
443 while (c.moveToNext()) {
444 folderIds.add(c.getLong(0));
445 }
446 c.close();
Sunny Goyald2497482015-09-22 18:24:19 -0700447 if (!folderIds.isEmpty()) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700448 db.delete(Favorites.TABLE_NAME, Utilities.createDbSelectionQuery(
Sunny Goyalb1622cc2015-06-10 16:00:42 -0700449 LauncherSettings.Favorites._ID, folderIds), null);
450 }
451 db.setTransactionSuccessful();
452 } catch (SQLException ex) {
453 Log.e(TAG, ex.getMessage(), ex);
454 folderIds.clear();
455 } finally {
456 db.endTransaction();
457 }
458 return folderIds;
459 }
460
Sunny Goyalf076eae2016-01-11 12:25:10 -0800461 /**
462 * Overridden in tests
463 */
464 protected void notifyListeners() {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700465 mListenerHandler.sendEmptyMessage(ChangeListenerWrapper.MSG_LAUNCHER_PROVIDER_CHANGED);
Chris Wren1ada10d2013-09-13 18:01:38 -0400466 }
467
Adam Cohen091440a2015-03-18 14:16:05 -0700468 @Thunk static void addModifiedTime(ContentValues values) {
Chris Wren1ada10d2013-09-13 18:01:38 -0400469 values.put(LauncherSettings.ChangeLogColumns.MODIFIED, System.currentTimeMillis());
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800470 }
471
Brian Muramatsu5524b492012-10-02 16:55:54 -0700472 /**
Sunny Goyal42de82f2014-09-26 22:09:29 -0700473 * Clears all the data for a fresh start.
474 */
Sunny Goyald2497482015-09-22 18:24:19 -0700475 synchronized private void createEmptyDB() {
Sunny Goyal42de82f2014-09-26 22:09:29 -0700476 mOpenHelper.createEmptyDB(mOpenHelper.getWritableDatabase());
477 }
478
Sunny Goyald2497482015-09-22 18:24:19 -0700479 private void clearFlagEmptyDbCreated() {
Sunny Goyalf7258242015-10-19 16:59:07 -0700480 Utilities.getPrefs(getContext()).edit().remove(EMPTY_DATABASE_CREATED).commit();
Sunny Goyal33d44382014-10-16 09:24:19 -0700481 }
482
Sunny Goyal42de82f2014-09-26 22:09:29 -0700483 /**
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700484 * Loads the default workspace based on the following priority scheme:
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700485 * 1) From the app restrictions
486 * 2) From a package provided by play store
487 * 3) From a partner configuration APK, already in the system image
488 * 4) The default configuration for the particular device
Brian Muramatsu5524b492012-10-02 16:55:54 -0700489 */
Sunny Goyald2497482015-09-22 18:24:19 -0700490 synchronized private void loadDefaultFavoritesIfNecessary() {
Sunny Goyalf7258242015-10-19 16:59:07 -0700491 SharedPreferences sp = Utilities.getPrefs(getContext());
Adam Cohene25af792013-06-06 23:08:25 -0700492
Winson Chungc763c4e2013-07-19 13:49:06 -0700493 if (sp.getBoolean(EMPTY_DATABASE_CREATED, false)) {
Chris Wren5dee7af2013-12-20 17:22:11 -0500494 Log.d(TAG, "loading default workspace");
Michael Jurka45355c42012-10-08 13:21:35 +0200495
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700496 AppWidgetHost widgetHost = new AppWidgetHost(getContext(), Launcher.APPWIDGET_HOST_ID);
497 AutoInstallsLayout loader = createWorkspaceLoaderFromAppRestriction(widgetHost);
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700498 if (loader == null) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700499 loader = AutoInstallsLayout.get(getContext(),widgetHost, mOpenHelper);
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700500 }
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700501 if (loader == null) {
Adam Cohen9b8f51f2014-05-30 15:34:09 -0700502 final Partner partner = Partner.get(getContext().getPackageManager());
503 if (partner != null && partner.hasDefaultLayout()) {
504 final Resources partnerRes = partner.getResources();
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700505 int workspaceResId = partnerRes.getIdentifier(Partner.RES_DEFAULT_LAYOUT,
Adam Cohen9b8f51f2014-05-30 15:34:09 -0700506 "xml", partner.getPackageName());
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700507 if (workspaceResId != 0) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700508 loader = new DefaultLayoutParser(getContext(), widgetHost,
Sunny Goyal3a5a9d12014-10-01 15:33:41 -0700509 mOpenHelper, partnerRes, workspaceResId);
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700510 }
Adam Cohen9b8f51f2014-05-30 15:34:09 -0700511 }
512 }
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700513
Sunny Goyal9d219682014-10-23 14:21:02 -0700514 final boolean usingExternallyProvidedLayout = loader != null;
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700515 if (loader == null) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700516 loader = getDefaultLayoutParser(widgetHost);
Brian Muramatsu5524b492012-10-02 16:55:54 -0700517 }
Sunny Goyalc6c8fef2015-03-04 09:51:18 -0800518
519 // There might be some partially restored DB items, due to buggy restore logic in
520 // previous versions of launcher.
521 createEmptyDB();
Michael Jurkab85f8a42012-04-25 15:48:32 -0700522 // Populate favorites table with initial favorites
Sunny Goyal9d219682014-10-23 14:21:02 -0700523 if ((mOpenHelper.loadFavorites(mOpenHelper.getWritableDatabase(), loader) <= 0)
524 && usingExternallyProvidedLayout) {
525 // Unable to load external layout. Cleanup and load the internal layout.
526 createEmptyDB();
527 mOpenHelper.loadFavorites(mOpenHelper.getWritableDatabase(),
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700528 getDefaultLayoutParser(widgetHost));
Sunny Goyal9d219682014-10-23 14:21:02 -0700529 }
Sunny Goyal33d44382014-10-16 09:24:19 -0700530 clearFlagEmptyDbCreated();
Michael Jurkab85f8a42012-04-25 15:48:32 -0700531 }
532 }
533
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700534 /**
535 * Creates workspace loader from an XML resource listed in the app restrictions.
536 *
537 * @return the loader if the restrictions are set and the resource exists; null otherwise.
538 */
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700539 private AutoInstallsLayout createWorkspaceLoaderFromAppRestriction(AppWidgetHost widgetHost) {
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700540 Context ctx = getContext();
541 UserManager um = (UserManager) ctx.getSystemService(Context.USER_SERVICE);
542 Bundle bundle = um.getApplicationRestrictions(ctx.getPackageName());
Sunny Goyal35ca8732015-04-06 10:45:31 -0700543 if (bundle == null) {
544 return null;
545 }
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700546
Sunny Goyal35ca8732015-04-06 10:45:31 -0700547 String packageName = bundle.getString(RESTRICTION_PACKAGE_NAME);
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700548 if (packageName != null) {
549 try {
550 Resources targetResources = ctx.getPackageManager()
551 .getResourcesForApplication(packageName);
552 return AutoInstallsLayout.get(ctx, packageName, targetResources,
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700553 widgetHost, mOpenHelper);
Sunny Goyalb2d46ce2015-03-26 11:32:11 -0700554 } catch (NameNotFoundException e) {
555 Log.e(TAG, "Target package for restricted profile not found", e);
556 return null;
557 }
558 }
559 return null;
560 }
561
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700562 private DefaultLayoutParser getDefaultLayoutParser(AppWidgetHost widgetHost) {
Sunny Goyal87f784c2017-01-11 10:48:34 -0800563 int defaultLayout = LauncherAppState.getIDP(getContext()).defaultLayoutId;
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700564 return new DefaultLayoutParser(getContext(), widgetHost,
Sunny Goyal9d219682014-10-23 14:21:02 -0700565 mOpenHelper, getContext().getResources(), defaultLayout);
566 }
567
Sunny Goyald3849d12015-10-29 10:28:32 -0700568 /**
Sunny Goyalf076eae2016-01-11 12:25:10 -0800569 * The class is subclassed in tests to create an in-memory db.
570 */
Sunny Goyalc190dbf2016-05-05 14:37:05 -0700571 public static class DatabaseHelper extends SQLiteOpenHelper implements LayoutParserCallback {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700572 private final Handler mWidgetHostResetHandler;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800573 private final Context mContext;
Adam Cohendcd297f2013-06-18 13:13:40 -0700574 private long mMaxItemId = -1;
575 private long mMaxScreenId = -1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800576
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700577 DatabaseHelper(Context context, Handler widgetHostResetHandler) {
578 this(context, widgetHostResetHandler, LauncherFiles.LAUNCHER_DB);
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700579 // Table creation sometimes fails silently, which leads to a crash loop.
580 // This way, we will try to create a table every time after crash, so the device
581 // would eventually be able to recover.
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700582 if (!tableExists(Favorites.TABLE_NAME) || !tableExists(WorkspaceScreens.TABLE_NAME)) {
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700583 Log.e(TAG, "Tables are missing after onCreate has been called. Trying to recreate");
584 // This operation is a no-op if the table already exists.
585 addFavoritesTable(getWritableDatabase(), true);
586 addWorkspacesTable(getWritableDatabase(), true);
587 }
588
Sunny Goyal7eab3cc2016-03-18 17:42:55 -0700589 initIds();
590 }
591
592 /**
Sunny Goyalc190dbf2016-05-05 14:37:05 -0700593 * Constructor used in tests and for restore.
Sunny Goyal7eab3cc2016-03-18 17:42:55 -0700594 */
595 public DatabaseHelper(
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700596 Context context, Handler widgetHostResetHandler, String tableName) {
Sunny Goyal7eab3cc2016-03-18 17:42:55 -0700597 super(new NoLocaleSqliteContext(context), tableName, null, DATABASE_VERSION);
598 mContext = context;
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700599 mWidgetHostResetHandler = widgetHostResetHandler;
Sunny Goyal7eab3cc2016-03-18 17:42:55 -0700600 }
601
602 protected void initIds() {
Winson Chung3d503fb2011-07-13 17:25:49 -0700603 // In the case where neither onCreate nor onUpgrade gets called, we read the maxId from
604 // the DB here
Adam Cohendcd297f2013-06-18 13:13:40 -0700605 if (mMaxItemId == -1) {
606 mMaxItemId = initializeMaxItemId(getWritableDatabase());
607 }
608 if (mMaxScreenId == -1) {
609 mMaxScreenId = initializeMaxScreenId(getWritableDatabase());
Winson Chung3d503fb2011-07-13 17:25:49 -0700610 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800611 }
612
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700613 private boolean tableExists(String tableName) {
614 Cursor c = getReadableDatabase().query(
615 true, "sqlite_master", new String[] {"tbl_name"},
616 "tbl_name = ?", new String[] {tableName},
617 null, null, null, null, null);
618 try {
619 return c.getCount() > 0;
620 } finally {
621 c.close();
622 }
623 }
624
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800625 @Override
626 public void onCreate(SQLiteDatabase db) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -0800627 if (LOGD) Log.d(TAG, "creating new launcher database");
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700628
Adam Cohendcd297f2013-06-18 13:13:40 -0700629 mMaxItemId = 1;
630 mMaxScreenId = 0;
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700631
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700632 addFavoritesTable(db, false);
633 addWorkspacesTable(db, false);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800634
Sunny Goyale87e6ab2014-11-21 22:42:53 -0800635 // Fresh and clean launcher DB.
636 mMaxItemId = initializeMaxItemId(db);
Sunny Goyalf076eae2016-01-11 12:25:10 -0800637 onEmptyDbCreated();
638 }
639
640 /**
641 * Overriden in tests.
642 */
643 protected void onEmptyDbCreated() {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700644 // Database was just created, so wipe any previous widgets
645 if (mWidgetHostResetHandler != null) {
646 new AppWidgetHost(mContext, Launcher.APPWIDGET_HOST_ID).deleteHost();
Sunny Goyal2e013ea2016-10-07 16:17:19 -0700647 mWidgetHostResetHandler.sendEmptyMessage(
Sunny Goyal72db9af2016-11-29 07:25:49 +0530648 ChangeListenerWrapper.MSG_APP_WIDGET_HOST_RESET);
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700649 }
650
Sunny Goyalf076eae2016-01-11 12:25:10 -0800651 // Set the flag for empty DB
652 Utilities.getPrefs(mContext).edit().putBoolean(EMPTY_DATABASE_CREATED, true).commit();
Sunny Goyale2fba6c2015-05-12 10:39:59 -0700653
654 // When a new DB is created, remove all previously stored managed profile information.
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800655 ManagedProfileHeuristic.processAllUsers(Collections.<UserHandle>emptyList(),
Sunny Goyalf076eae2016-01-11 12:25:10 -0800656 mContext);
657 }
658
Sunny Goyale8f7d5a2016-05-24 11:30:14 -0700659 public long getDefaultUserSerial() {
Sunny Goyalf076eae2016-01-11 12:25:10 -0800660 return UserManagerCompat.getInstance(mContext).getSerialNumberForUser(
Sunny Goyal7c74e4a2016-12-15 15:53:17 -0800661 Process.myUserHandle());
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800662 }
663
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700664 private void addFavoritesTable(SQLiteDatabase db, boolean optional) {
Sunny Goyalc190dbf2016-05-05 14:37:05 -0700665 Favorites.addTableToDb(db, getDefaultUserSerial(), optional);
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700666 }
667
668 private void addWorkspacesTable(SQLiteDatabase db, boolean optional) {
669 String ifNotExists = optional ? " IF NOT EXISTS " : "";
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700670 db.execSQL("CREATE TABLE " + ifNotExists + WorkspaceScreens.TABLE_NAME + " (" +
Sunny Goyald2f38192015-02-25 10:46:34 -0800671 LauncherSettings.WorkspaceScreens._ID + " INTEGER PRIMARY KEY," +
Chris Wren1ada10d2013-09-13 18:01:38 -0400672 LauncherSettings.WorkspaceScreens.SCREEN_RANK + " INTEGER," +
673 LauncherSettings.ChangeLogColumns.MODIFIED + " INTEGER NOT NULL DEFAULT 0" +
Adam Cohendcd297f2013-06-18 13:13:40 -0700674 ");");
675 }
676
Adam Cohen119285e2014-04-02 16:59:08 -0700677 private void removeOrphanedItems(SQLiteDatabase db) {
Adam Cohenf9c14de2014-04-17 18:20:45 -0700678 // Delete items directly on the workspace who's screen id doesn't exist
679 // "DELETE FROM favorites WHERE screen NOT IN (SELECT _id FROM workspaceScreens)
680 // AND container = -100"
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700681 String removeOrphanedDesktopItems = "DELETE FROM " + Favorites.TABLE_NAME +
Adam Cohenf9c14de2014-04-17 18:20:45 -0700682 " WHERE " +
Adam Cohen119285e2014-04-02 16:59:08 -0700683 LauncherSettings.Favorites.SCREEN + " NOT IN (SELECT " +
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700684 LauncherSettings.WorkspaceScreens._ID + " FROM " + WorkspaceScreens.TABLE_NAME + ")" +
Adam Cohenf9c14de2014-04-17 18:20:45 -0700685 " AND " +
686 LauncherSettings.Favorites.CONTAINER + " = " +
687 LauncherSettings.Favorites.CONTAINER_DESKTOP;
688 db.execSQL(removeOrphanedDesktopItems);
689
690 // Delete items contained in folders which no longer exist (after above statement)
691 // "DELETE FROM favorites WHERE container <> -100 AND container <> -101 AND container
692 // NOT IN (SELECT _id FROM favorites WHERE itemType = 2)"
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700693 String removeOrphanedFolderItems = "DELETE FROM " + Favorites.TABLE_NAME +
Adam Cohenf9c14de2014-04-17 18:20:45 -0700694 " WHERE " +
695 LauncherSettings.Favorites.CONTAINER + " <> " +
696 LauncherSettings.Favorites.CONTAINER_DESKTOP +
697 " AND "
698 + LauncherSettings.Favorites.CONTAINER + " <> " +
699 LauncherSettings.Favorites.CONTAINER_HOTSEAT +
700 " AND "
701 + LauncherSettings.Favorites.CONTAINER + " NOT IN (SELECT " +
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700702 LauncherSettings.Favorites._ID + " FROM " + Favorites.TABLE_NAME +
Adam Cohenf9c14de2014-04-17 18:20:45 -0700703 " WHERE " + LauncherSettings.Favorites.ITEM_TYPE + " = " +
704 LauncherSettings.Favorites.ITEM_TYPE_FOLDER + ")";
705 db.execSQL(removeOrphanedFolderItems);
Adam Cohen119285e2014-04-02 16:59:08 -0700706 }
707
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800708 @Override
709 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Winson Chungc763c4e2013-07-19 13:49:06 -0700710 if (LOGD) Log.d(TAG, "onUpgrade triggered: " + oldVersion);
Sunny Goyala2cc6242015-01-14 14:23:02 -0800711 switch (oldVersion) {
712 // The version cannot be lower that 12, as Launcher3 never supported a lower
Sunny Goyale87e6ab2014-11-21 22:42:53 -0800713 // version of the DB.
Sunny Goyala2cc6242015-01-14 14:23:02 -0800714 case 12: {
715 // With the new shrink-wrapped and re-orderable workspaces, it makes sense
716 // to persist workspace screens and their relative order.
717 mMaxScreenId = 0;
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700718 addWorkspacesTable(db, false);
Sunny Goyala2cc6242015-01-14 14:23:02 -0800719 }
720 case 13: {
721 db.beginTransaction();
722 try {
723 // Insert new column for holding widget provider name
724 db.execSQL("ALTER TABLE favorites " +
725 "ADD COLUMN appWidgetProvider TEXT;");
726 db.setTransactionSuccessful();
727 } catch (SQLException ex) {
728 Log.e(TAG, ex.getMessage(), ex);
729 // Old version remains, which means we wipe old data
730 break;
731 } finally {
732 db.endTransaction();
733 }
734 }
735 case 14: {
736 db.beginTransaction();
737 try {
738 // Insert new column for holding update timestamp
739 db.execSQL("ALTER TABLE favorites " +
740 "ADD COLUMN modified INTEGER NOT NULL DEFAULT 0;");
741 db.execSQL("ALTER TABLE workspaceScreens " +
742 "ADD COLUMN modified INTEGER NOT NULL DEFAULT 0;");
743 db.setTransactionSuccessful();
744 } catch (SQLException ex) {
745 Log.e(TAG, ex.getMessage(), ex);
746 // Old version remains, which means we wipe old data
747 break;
748 } finally {
749 db.endTransaction();
750 }
751 }
752 case 15: {
Sunny Goyal5d85c442015-03-10 13:14:47 -0700753 if (!addIntegerColumn(db, Favorites.RESTORED, 0)) {
Sunny Goyala2cc6242015-01-14 14:23:02 -0800754 // Old version remains, which means we wipe old data
755 break;
Sunny Goyala2cc6242015-01-14 14:23:02 -0800756 }
757 }
758 case 16: {
Sunny Goyal10629b02016-09-01 12:50:11 -0700759 // No-op
Sunny Goyala2cc6242015-01-14 14:23:02 -0800760 }
761 case 17: {
762 // No-op
763 }
764 case 18: {
765 // Due to a data loss bug, some users may have items associated with screen ids
766 // which no longer exist. Since this can cause other problems, and since the user
767 // will never see these items anyway, we use database upgrade as an opportunity to
768 // clean things up.
769 removeOrphanedItems(db);
770 }
771 case 19: {
772 // Add userId column
773 if (!addProfileColumn(db)) {
774 // Old version remains, which means we wipe old data
775 break;
776 }
777 }
778 case 20:
779 if (!updateFolderItemsRank(db, true)) {
780 break;
781 }
Sunny Goyald2f38192015-02-25 10:46:34 -0800782 case 21:
783 // Recreate workspace table with screen id a primary key
784 if (!recreateWorkspaceTable(db)) {
785 break;
786 }
787 case 22: {
Sunny Goyal5d85c442015-03-10 13:14:47 -0700788 if (!addIntegerColumn(db, Favorites.OPTIONS, 0)) {
789 // Old version remains, which means we wipe old data
790 break;
791 }
792 }
Sunny Goyal0b037782015-04-02 10:27:03 -0700793 case 23:
Sunny Goyal5c97f512015-05-19 16:03:28 -0700794 // No-op
Sunny Goyale2fba6c2015-05-12 10:39:59 -0700795 case 24:
796 ManagedProfileHeuristic.markExistingUsersForNoFolderCreation(mContext);
Sunny Goyal5c97f512015-05-19 16:03:28 -0700797 case 25:
798 convertShortcutsToLauncherActivities(db);
Sunny Goyala9e2f5a2016-06-10 12:22:04 -0700799 case 26:
800 // QSB was moved to the grid. Clear the first row on screen 0.
801 if (FeatureFlags.QSB_ON_FIRST_SCREEN &&
Sunny Goyal8ad02b82016-12-29 13:31:43 -0800802 !LauncherDbUtils.prepareScreenZeroToHostQsb(mContext, db)) {
Sunny Goyala9e2f5a2016-06-10 12:22:04 -0700803 break;
804 }
805 case 27: {
Sunny Goyala2cc6242015-01-14 14:23:02 -0800806 // DB Upgraded successfully
807 return;
Chris Wrend5e66bf2013-09-16 14:02:29 -0400808 }
809 }
810
Sunny Goyala2cc6242015-01-14 14:23:02 -0800811 // DB was not upgraded
812 Log.w(TAG, "Destroying all old data.");
813 createEmptyDB(db);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800814 }
Romain Guy7eb9e5e2009-12-02 20:10:07 -0800815
Adam Cohen9b1d0622014-05-21 19:01:57 -0700816 @Override
817 public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
818 // This shouldn't happen -- throw our hands up in the air and start over.
819 Log.w(TAG, "Database version downgrade from: " + oldVersion + " to " + newVersion +
820 ". Wiping databse.");
Sunny Goyal42de82f2014-09-26 22:09:29 -0700821 createEmptyDB(db);
822 }
Adam Cohen9b1d0622014-05-21 19:01:57 -0700823
Sunny Goyal42de82f2014-09-26 22:09:29 -0700824 /**
825 * Clears all the data for a fresh start.
826 */
827 public void createEmptyDB(SQLiteDatabase db) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700828 db.execSQL("DROP TABLE IF EXISTS " + Favorites.TABLE_NAME);
829 db.execSQL("DROP TABLE IF EXISTS " + WorkspaceScreens.TABLE_NAME);
Adam Cohen9b1d0622014-05-21 19:01:57 -0700830 onCreate(db);
831 }
832
Sunny Goyald2f38192015-02-25 10:46:34 -0800833 /**
Sunny Goyal0b037782015-04-02 10:27:03 -0700834 * Replaces all shortcuts of type {@link Favorites#ITEM_TYPE_SHORTCUT} which have a valid
835 * launcher activity target with {@link Favorites#ITEM_TYPE_APPLICATION}.
836 */
Sunny Goyal316490e2015-06-02 09:38:28 -0700837 @Thunk void convertShortcutsToLauncherActivities(SQLiteDatabase db) {
Sunny Goyal0b037782015-04-02 10:27:03 -0700838 db.beginTransaction();
839 Cursor c = null;
840 SQLiteStatement updateStmt = null;
841
842 try {
843 // Only consider the primary user as other users can't have a shortcut.
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700844 long userSerial = getDefaultUserSerial();
845 c = db.query(Favorites.TABLE_NAME, new String[] {
Sunny Goyal0b037782015-04-02 10:27:03 -0700846 Favorites._ID,
847 Favorites.INTENT,
848 }, "itemType=" + Favorites.ITEM_TYPE_SHORTCUT + " AND profileId=" + userSerial,
849 null, null, null, null);
850
851 updateStmt = db.compileStatement("UPDATE favorites SET itemType="
852 + Favorites.ITEM_TYPE_APPLICATION + " WHERE _id=?");
853
854 final int idIndex = c.getColumnIndexOrThrow(Favorites._ID);
855 final int intentIndex = c.getColumnIndexOrThrow(Favorites.INTENT);
856
857 while (c.moveToNext()) {
858 String intentDescription = c.getString(intentIndex);
859 Intent intent;
860 try {
861 intent = Intent.parseUri(intentDescription, 0);
862 } catch (URISyntaxException e) {
863 Log.e(TAG, "Unable to parse intent", e);
864 continue;
865 }
866
Sunny Goyal4e5cc642015-06-25 16:37:44 -0700867 if (!Utilities.isLauncherAppTarget(intent)) {
Sunny Goyal0b037782015-04-02 10:27:03 -0700868 continue;
869 }
870
871 long id = c.getLong(idIndex);
872 updateStmt.bindLong(1, id);
Sunny Goyalc22841b2015-07-13 19:59:50 -0700873 updateStmt.executeUpdateDelete();
Sunny Goyal0b037782015-04-02 10:27:03 -0700874 }
875 db.setTransactionSuccessful();
876 } catch (SQLException ex) {
877 Log.w(TAG, "Error deduping shortcuts", ex);
878 } finally {
879 db.endTransaction();
880 if (c != null) {
881 c.close();
882 }
883 if (updateStmt != null) {
884 updateStmt.close();
885 }
886 }
887 }
888
889 /**
Sunny Goyald2f38192015-02-25 10:46:34 -0800890 * Recreates workspace table and migrates data to the new table.
891 */
892 public boolean recreateWorkspaceTable(SQLiteDatabase db) {
893 db.beginTransaction();
894 try {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700895 Cursor c = db.query(WorkspaceScreens.TABLE_NAME,
Sunny Goyald2f38192015-02-25 10:46:34 -0800896 new String[] {LauncherSettings.WorkspaceScreens._ID},
897 null, null, null, null,
898 LauncherSettings.WorkspaceScreens.SCREEN_RANK);
899 ArrayList<Long> sortedIDs = new ArrayList<Long>();
900 long maxId = 0;
901 try {
902 while (c.moveToNext()) {
903 Long id = c.getLong(0);
904 if (!sortedIDs.contains(id)) {
905 sortedIDs.add(id);
906 maxId = Math.max(maxId, id);
907 }
908 }
909 } finally {
910 c.close();
911 }
912
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700913 db.execSQL("DROP TABLE IF EXISTS " + WorkspaceScreens.TABLE_NAME);
Sunny Goyal6fb929e2015-09-23 11:40:53 -0700914 addWorkspacesTable(db, false);
Sunny Goyald2f38192015-02-25 10:46:34 -0800915
916 // Add all screen ids back
917 int total = sortedIDs.size();
918 for (int i = 0; i < total; i++) {
919 ContentValues values = new ContentValues();
920 values.put(LauncherSettings.WorkspaceScreens._ID, sortedIDs.get(i));
921 values.put(LauncherSettings.WorkspaceScreens.SCREEN_RANK, i);
922 addModifiedTime(values);
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700923 db.insertOrThrow(WorkspaceScreens.TABLE_NAME, null, values);
Sunny Goyald2f38192015-02-25 10:46:34 -0800924 }
925 db.setTransactionSuccessful();
926 mMaxScreenId = maxId;
927 } catch (SQLException ex) {
928 // Old version remains, which means we wipe old data
929 Log.e(TAG, ex.getMessage(), ex);
930 return false;
931 } finally {
932 db.endTransaction();
933 }
934 return true;
935 }
936
Adam Cohen091440a2015-03-18 14:16:05 -0700937 @Thunk boolean updateFolderItemsRank(SQLiteDatabase db, boolean addRankColumn) {
Sunny Goyal08f72612015-01-05 13:41:43 -0800938 db.beginTransaction();
939 try {
940 if (addRankColumn) {
941 // Insert new column for holding rank
942 db.execSQL("ALTER TABLE favorites ADD COLUMN rank INTEGER NOT NULL DEFAULT 0;");
943 }
944
945 // Get a map for folder ID to folder width
946 Cursor c = db.rawQuery("SELECT container, MAX(cellX) FROM favorites"
947 + " WHERE container IN (SELECT _id FROM favorites WHERE itemType = ?)"
948 + " GROUP BY container;",
949 new String[] {Integer.toString(LauncherSettings.Favorites.ITEM_TYPE_FOLDER)});
950
951 while (c.moveToNext()) {
Sunny Goyalc87775d2015-02-10 19:52:36 -0800952 db.execSQL("UPDATE favorites SET rank=cellX+(cellY*?) WHERE "
953 + "container=? AND cellX IS NOT NULL AND cellY IS NOT NULL;",
Sunny Goyal08f72612015-01-05 13:41:43 -0800954 new Object[] {c.getLong(1) + 1, c.getLong(0)});
955 }
956
957 c.close();
958 db.setTransactionSuccessful();
959 } catch (SQLException ex) {
960 // Old version remains, which means we wipe old data
961 Log.e(TAG, ex.getMessage(), ex);
962 return false;
963 } finally {
964 db.endTransaction();
965 }
966 return true;
967 }
968
Kenny Guyed131872014-04-30 03:02:21 +0100969 private boolean addProfileColumn(SQLiteDatabase db) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -0700970 return addIntegerColumn(db, Favorites.PROFILE_ID, getDefaultUserSerial());
Sunny Goyal5d85c442015-03-10 13:14:47 -0700971 }
972
973 private boolean addIntegerColumn(SQLiteDatabase db, String columnName, long defaultValue) {
Kenny Guyed131872014-04-30 03:02:21 +0100974 db.beginTransaction();
975 try {
Sunny Goyal5d85c442015-03-10 13:14:47 -0700976 db.execSQL("ALTER TABLE favorites ADD COLUMN "
977 + columnName + " INTEGER NOT NULL DEFAULT " + defaultValue + ";");
Kenny Guyed131872014-04-30 03:02:21 +0100978 db.setTransactionSuccessful();
979 } catch (SQLException ex) {
Kenny Guyed131872014-04-30 03:02:21 +0100980 Log.e(TAG, ex.getMessage(), ex);
981 return false;
982 } finally {
983 db.endTransaction();
984 }
985 return true;
986 }
987
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700988 // Generates a new ID to use for an object in your database. This method should be only
989 // called from the main UI thread. As an exception, we do call it when we call the
990 // constructor from the worker thread; however, this doesn't extend until after the
991 // constructor is called, and we only pass a reference to LauncherProvider to LauncherApp
992 // after that point
Sunny Goyal0fe505b2014-08-06 09:55:36 -0700993 @Override
Adam Cohendcd297f2013-06-18 13:13:40 -0700994 public long generateNewItemId() {
995 if (mMaxItemId < 0) {
996 throw new RuntimeException("Error: max item id was not initialized");
Michael Jurkaa8c760d2011-04-28 14:59:33 -0700997 }
Adam Cohendcd297f2013-06-18 13:13:40 -0700998 mMaxItemId += 1;
999 return mMaxItemId;
Michael Jurkaa8c760d2011-04-28 14:59:33 -07001000 }
1001
Sunny Goyal0fe505b2014-08-06 09:55:36 -07001002 @Override
1003 public long insertAndCheck(SQLiteDatabase db, ContentValues values) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001004 return dbInsertAndCheck(this, db, Favorites.TABLE_NAME, null, values);
Sunny Goyal0fe505b2014-08-06 09:55:36 -07001005 }
1006
Chris Wren5dee7af2013-12-20 17:22:11 -05001007 public void checkId(String table, ContentValues values) {
1008 long id = values.getAsLong(LauncherSettings.BaseLauncherColumns._ID);
Sunny Goyal8e0e1d72016-10-10 10:41:41 -07001009 if (WorkspaceScreens.TABLE_NAME.equals(table)) {
Chris Wren5dee7af2013-12-20 17:22:11 -05001010 mMaxScreenId = Math.max(id, mMaxScreenId);
1011 } else {
1012 mMaxItemId = Math.max(id, mMaxItemId);
1013 }
1014 }
1015
Adam Cohendcd297f2013-06-18 13:13:40 -07001016 private long initializeMaxItemId(SQLiteDatabase db) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001017 return getMaxId(db, Favorites.TABLE_NAME);
Adam Cohendcd297f2013-06-18 13:13:40 -07001018 }
1019
1020 // Generates a new ID to use for an workspace screen in your database. This method
1021 // should be only called from the main UI thread. As an exception, we do call it when we
1022 // call the constructor from the worker thread; however, this doesn't extend until after the
1023 // constructor is called, and we only pass a reference to LauncherProvider to LauncherApp
1024 // after that point
1025 public long generateNewScreenId() {
1026 if (mMaxScreenId < 0) {
1027 throw new RuntimeException("Error: max screen id was not initialized");
1028 }
1029 mMaxScreenId += 1;
1030 return mMaxScreenId;
1031 }
1032
Adam Cohendcd297f2013-06-18 13:13:40 -07001033 private long initializeMaxScreenId(SQLiteDatabase db) {
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001034 return getMaxId(db, WorkspaceScreens.TABLE_NAME);
Adam Cohen7ec3bbf2014-07-31 00:09:45 -07001035 }
1036
Adam Cohen091440a2015-03-18 14:16:05 -07001037 @Thunk int loadFavorites(SQLiteDatabase db, AutoInstallsLayout loader) {
Adam Cohen71483f42014-05-15 14:04:01 -07001038 ArrayList<Long> screenIds = new ArrayList<Long>();
Sunny Goyal0fe505b2014-08-06 09:55:36 -07001039 // TODO: Use multiple loaders with fall-back and transaction.
1040 int count = loader.loadLayout(db, screenIds);
Adam Cohen71483f42014-05-15 14:04:01 -07001041
1042 // Add the screens specified by the items above
1043 Collections.sort(screenIds);
1044 int rank = 0;
1045 ContentValues values = new ContentValues();
1046 for (Long id : screenIds) {
1047 values.clear();
1048 values.put(LauncherSettings.WorkspaceScreens._ID, id);
1049 values.put(LauncherSettings.WorkspaceScreens.SCREEN_RANK, rank);
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001050 if (dbInsertAndCheck(this, db, WorkspaceScreens.TABLE_NAME, null, values) < 0) {
Adam Cohen71483f42014-05-15 14:04:01 -07001051 throw new RuntimeException("Failed initialize screen table"
1052 + "from default layout");
1053 }
1054 rank++;
1055 }
1056
1057 // Ensure that the max ids are initialized
1058 mMaxItemId = initializeMaxItemId(db);
1059 mMaxScreenId = initializeMaxScreenId(db);
Adam Cohen7ec3bbf2014-07-31 00:09:45 -07001060
Adam Cohen71483f42014-05-15 14:04:01 -07001061 return count;
1062 }
Mike Cleronb87bd162009-10-30 16:36:56 -07001063 }
Daniel Lehmannc3a80402012-04-23 21:35:11 -07001064
Sunny Goyalfe4e4b92015-03-04 10:43:45 -08001065 /**
1066 * @return the max _id in the provided table.
1067 */
Adam Cohen091440a2015-03-18 14:16:05 -07001068 @Thunk static long getMaxId(SQLiteDatabase db, String table) {
Sunny Goyalfe4e4b92015-03-04 10:43:45 -08001069 Cursor c = db.rawQuery("SELECT MAX(_id) FROM " + table, null);
1070 // get the result
1071 long id = -1;
1072 if (c != null && c.moveToNext()) {
1073 id = c.getLong(0);
1074 }
1075 if (c != null) {
1076 c.close();
1077 }
1078
1079 if (id == -1) {
1080 throw new RuntimeException("Error: could not query max id in " + table);
1081 }
1082
1083 return id;
1084 }
1085
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001086 static class SqlArguments {
1087 public final String table;
1088 public final String where;
1089 public final String[] args;
1090
1091 SqlArguments(Uri url, String where, String[] args) {
1092 if (url.getPathSegments().size() == 1) {
1093 this.table = url.getPathSegments().get(0);
1094 this.where = where;
1095 this.args = args;
1096 } else if (url.getPathSegments().size() != 2) {
1097 throw new IllegalArgumentException("Invalid URI: " + url);
1098 } else if (!TextUtils.isEmpty(where)) {
1099 throw new UnsupportedOperationException("WHERE clause not supported: " + url);
1100 } else {
1101 this.table = url.getPathSegments().get(0);
Daniel Lehmannc3a80402012-04-23 21:35:11 -07001102 this.where = "_id=" + ContentUris.parseId(url);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001103 this.args = null;
1104 }
1105 }
1106
1107 SqlArguments(Uri url) {
1108 if (url.getPathSegments().size() == 1) {
1109 table = url.getPathSegments().get(0);
1110 where = null;
1111 args = null;
1112 } else {
1113 throw new IllegalArgumentException("Invalid URI: " + url);
1114 }
1115 }
1116 }
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001117
1118 private static class ChangeListenerWrapper implements Handler.Callback {
1119
1120 private static final int MSG_LAUNCHER_PROVIDER_CHANGED = 1;
1121 private static final int MSG_EXTRACTED_COLORS_CHANGED = 2;
1122 private static final int MSG_APP_WIDGET_HOST_RESET = 3;
1123
1124 private LauncherProviderChangeListener mListener;
1125
1126 @Override
1127 public boolean handleMessage(Message msg) {
1128 if (mListener != null) {
1129 switch (msg.what) {
1130 case MSG_LAUNCHER_PROVIDER_CHANGED:
Sunny Goyal2e013ea2016-10-07 16:17:19 -07001131 mListener.onLauncherProviderChanged();
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001132 break;
1133 case MSG_EXTRACTED_COLORS_CHANGED:
1134 mListener.onExtractedColorsChanged();
1135 break;
1136 case MSG_APP_WIDGET_HOST_RESET:
Sunny Goyal2e013ea2016-10-07 16:17:19 -07001137 mListener.onAppWidgetHostReset();
Sunny Goyalb5b55c82016-05-10 12:28:59 -07001138 break;
1139 }
1140 }
1141 return true;
1142 }
1143 }
Adam Cohen72960972014-01-15 18:13:55 -08001144}