1 /* 2 * Copyright (C) 2014 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 17 package com.android.launcher3; 18 19 import android.appwidget.AppWidgetHost; 20 import android.appwidget.AppWidgetManager; 21 import android.content.ComponentName; 22 import android.content.ContentValues; 23 import android.content.Context; 24 import android.content.Intent; 25 import android.content.pm.ActivityInfo; 26 import android.content.pm.PackageManager; 27 import android.content.res.Resources; 28 import android.content.res.XmlResourceParser; 29 import android.database.sqlite.SQLiteDatabase; 30 import android.graphics.drawable.Drawable; 31 import android.net.Uri; 32 import android.os.Bundle; 33 import android.text.TextUtils; 34 import android.util.Log; 35 import android.util.Pair; 36 import android.util.Patterns; 37 38 import com.android.launcher3.LauncherProvider.SqlArguments; 39 import com.android.launcher3.LauncherSettings.Favorites; 40 import com.android.launcher3.config.FeatureFlags; 41 import com.android.launcher3.util.Thunk; 42 43 import org.xmlpull.v1.XmlPullParser; 44 import org.xmlpull.v1.XmlPullParserException; 45 46 import java.io.IOException; 47 import java.util.ArrayList; 48 import java.util.HashMap; 49 import java.util.Locale; 50 51 /** 52 * Layout parsing code for auto installs layout 53 */ 54 public class AutoInstallsLayout { 55 private static final String TAG = "AutoInstalls"; 56 private static final boolean LOGD = false; 57 58 /** Marker action used to discover a package which defines launcher customization */ 59 static final String ACTION_LAUNCHER_CUSTOMIZATION = 60 "android.autoinstalls.config.action.PLAY_AUTO_INSTALL"; 61 62 /** 63 * Layout resource which also includes grid size and hotseat count, e.g., default_layout_6x6_h5 64 */ 65 private static final String FORMATTED_LAYOUT_RES_WITH_HOSTEAT = "default_layout_%dx%d_h%s"; 66 private static final String FORMATTED_LAYOUT_RES = "default_layout_%dx%d"; 67 private static final String LAYOUT_RES = "default_layout"; 68 get(Context context, AppWidgetHost appWidgetHost, LayoutParserCallback callback)69 static AutoInstallsLayout get(Context context, AppWidgetHost appWidgetHost, 70 LayoutParserCallback callback) { 71 Pair<String, Resources> customizationApkInfo = Utilities.findSystemApk( 72 ACTION_LAUNCHER_CUSTOMIZATION, context.getPackageManager()); 73 if (customizationApkInfo == null) { 74 return null; 75 } 76 return get(context, customizationApkInfo.first, customizationApkInfo.second, 77 appWidgetHost, callback); 78 } 79 get(Context context, String pkg, Resources targetRes, AppWidgetHost appWidgetHost, LayoutParserCallback callback)80 static AutoInstallsLayout get(Context context, String pkg, Resources targetRes, 81 AppWidgetHost appWidgetHost, LayoutParserCallback callback) { 82 InvariantDeviceProfile grid = LauncherAppState.getInstance().getInvariantDeviceProfile(); 83 84 // Try with grid size and hotseat count 85 String layoutName = String.format(Locale.ENGLISH, FORMATTED_LAYOUT_RES_WITH_HOSTEAT, 86 (int) grid.numColumns, (int) grid.numRows, (int) grid.numHotseatIcons); 87 int layoutId = targetRes.getIdentifier(layoutName, "xml", pkg); 88 89 // Try with only grid size 90 if (layoutId == 0) { 91 Log.d(TAG, "Formatted layout: " + layoutName 92 + " not found. Trying layout without hosteat"); 93 layoutName = String.format(Locale.ENGLISH, FORMATTED_LAYOUT_RES, 94 (int) grid.numColumns, (int) grid.numRows); 95 layoutId = targetRes.getIdentifier(layoutName, "xml", pkg); 96 } 97 98 // Try the default layout 99 if (layoutId == 0) { 100 Log.d(TAG, "Formatted layout: " + layoutName + " not found. Trying the default layout"); 101 layoutId = targetRes.getIdentifier(LAYOUT_RES, "xml", pkg); 102 } 103 104 if (layoutId == 0) { 105 Log.e(TAG, "Layout definition not found in package: " + pkg); 106 return null; 107 } 108 return new AutoInstallsLayout(context, appWidgetHost, callback, targetRes, layoutId, 109 TAG_WORKSPACE); 110 } 111 112 // Object Tags 113 private static final String TAG_INCLUDE = "include"; 114 private static final String TAG_WORKSPACE = "workspace"; 115 private static final String TAG_APP_ICON = "appicon"; 116 private static final String TAG_AUTO_INSTALL = "autoinstall"; 117 private static final String TAG_FOLDER = "folder"; 118 private static final String TAG_APPWIDGET = "appwidget"; 119 private static final String TAG_SHORTCUT = "shortcut"; 120 private static final String TAG_EXTRA = "extra"; 121 122 private static final String ATTR_CONTAINER = "container"; 123 private static final String ATTR_RANK = "rank"; 124 125 private static final String ATTR_PACKAGE_NAME = "packageName"; 126 private static final String ATTR_CLASS_NAME = "className"; 127 private static final String ATTR_TITLE = "title"; 128 private static final String ATTR_SCREEN = "screen"; 129 130 // x and y can be specified as negative integers, in which case -1 represents the 131 // last row / column, -2 represents the second last, and so on. 132 private static final String ATTR_X = "x"; 133 private static final String ATTR_Y = "y"; 134 135 private static final String ATTR_SPAN_X = "spanX"; 136 private static final String ATTR_SPAN_Y = "spanY"; 137 private static final String ATTR_ICON = "icon"; 138 private static final String ATTR_URL = "url"; 139 140 // Attrs for "Include" 141 private static final String ATTR_WORKSPACE = "workspace"; 142 143 // Style attrs -- "Extra" 144 private static final String ATTR_KEY = "key"; 145 private static final String ATTR_VALUE = "value"; 146 147 private static final String HOTSEAT_CONTAINER_NAME = 148 Favorites.containerToString(Favorites.CONTAINER_HOTSEAT); 149 150 private static final String ACTION_APPWIDGET_DEFAULT_WORKSPACE_CONFIGURE = 151 "com.android.launcher.action.APPWIDGET_DEFAULT_WORKSPACE_CONFIGURE"; 152 153 @Thunk final Context mContext; 154 @Thunk final AppWidgetHost mAppWidgetHost; 155 protected final LayoutParserCallback mCallback; 156 157 protected final PackageManager mPackageManager; 158 protected final Resources mSourceRes; 159 protected final int mLayoutId; 160 161 private final InvariantDeviceProfile mIdp; 162 private final int mRowCount; 163 private final int mColumnCount; 164 165 private final long[] mTemp = new long[2]; 166 @Thunk final ContentValues mValues; 167 protected final String mRootTag; 168 169 protected SQLiteDatabase mDb; 170 AutoInstallsLayout(Context context, AppWidgetHost appWidgetHost, LayoutParserCallback callback, Resources res, int layoutId, String rootTag)171 public AutoInstallsLayout(Context context, AppWidgetHost appWidgetHost, 172 LayoutParserCallback callback, Resources res, 173 int layoutId, String rootTag) { 174 mContext = context; 175 mAppWidgetHost = appWidgetHost; 176 mCallback = callback; 177 178 mPackageManager = context.getPackageManager(); 179 mValues = new ContentValues(); 180 mRootTag = rootTag; 181 182 mSourceRes = res; 183 mLayoutId = layoutId; 184 185 mIdp = LauncherAppState.getInstance().getInvariantDeviceProfile(); 186 mRowCount = mIdp.numRows; 187 mColumnCount = mIdp.numColumns; 188 } 189 190 /** 191 * Loads the layout in the db and returns the number of entries added on the desktop. 192 */ loadLayout(SQLiteDatabase db, ArrayList<Long> screenIds)193 public int loadLayout(SQLiteDatabase db, ArrayList<Long> screenIds) { 194 mDb = db; 195 try { 196 return parseLayout(mLayoutId, screenIds); 197 } catch (Exception e) { 198 Log.w(TAG, "Got exception parsing layout.", e); 199 return -1; 200 } 201 } 202 203 /** 204 * Parses the layout and returns the number of elements added on the homescreen. 205 */ parseLayout(int layoutId, ArrayList<Long> screenIds)206 protected int parseLayout(int layoutId, ArrayList<Long> screenIds) 207 throws XmlPullParserException, IOException { 208 XmlResourceParser parser = mSourceRes.getXml(layoutId); 209 beginDocument(parser, mRootTag); 210 final int depth = parser.getDepth(); 211 int type; 212 HashMap<String, TagParser> tagParserMap = getLayoutElementsMap(); 213 int count = 0; 214 215 while (((type = parser.next()) != XmlPullParser.END_TAG || 216 parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) { 217 if (type != XmlPullParser.START_TAG) { 218 continue; 219 } 220 count += parseAndAddNode(parser, tagParserMap, screenIds); 221 } 222 return count; 223 } 224 225 /** 226 * Parses container and screenId attribute from the current tag, and puts it in the out. 227 * @param out array of size 2. 228 */ parseContainerAndScreen(XmlResourceParser parser, long[] out)229 protected void parseContainerAndScreen(XmlResourceParser parser, long[] out) { 230 if (HOTSEAT_CONTAINER_NAME.equals(getAttributeValue(parser, ATTR_CONTAINER))) { 231 out[0] = Favorites.CONTAINER_HOTSEAT; 232 // Hack: hotseat items are stored using screen ids 233 long rank = Long.parseLong(getAttributeValue(parser, ATTR_RANK)); 234 out[1] = (FeatureFlags.NO_ALL_APPS_ICON || rank < mIdp.getAllAppsButtonRank()) 235 ? rank : (rank + 1); 236 } else { 237 out[0] = Favorites.CONTAINER_DESKTOP; 238 out[1] = Long.parseLong(getAttributeValue(parser, ATTR_SCREEN)); 239 } 240 } 241 242 /** 243 * Parses the current node and returns the number of elements added. 244 */ parseAndAddNode( XmlResourceParser parser, HashMap<String, TagParser> tagParserMap, ArrayList<Long> screenIds)245 protected int parseAndAddNode( 246 XmlResourceParser parser, 247 HashMap<String, TagParser> tagParserMap, 248 ArrayList<Long> screenIds) 249 throws XmlPullParserException, IOException { 250 251 if (TAG_INCLUDE.equals(parser.getName())) { 252 final int resId = getAttributeResourceValue(parser, ATTR_WORKSPACE, 0); 253 if (resId != 0) { 254 // recursively load some more favorites, why not? 255 return parseLayout(resId, screenIds); 256 } else { 257 return 0; 258 } 259 } 260 261 mValues.clear(); 262 parseContainerAndScreen(parser, mTemp); 263 final long container = mTemp[0]; 264 final long screenId = mTemp[1]; 265 266 mValues.put(Favorites.CONTAINER, container); 267 mValues.put(Favorites.SCREEN, screenId); 268 269 mValues.put(Favorites.CELLX, 270 convertToDistanceFromEnd(getAttributeValue(parser, ATTR_X), mColumnCount)); 271 mValues.put(Favorites.CELLY, 272 convertToDistanceFromEnd(getAttributeValue(parser, ATTR_Y), mRowCount)); 273 274 TagParser tagParser = tagParserMap.get(parser.getName()); 275 if (tagParser == null) { 276 if (LOGD) Log.d(TAG, "Ignoring unknown element tag: " + parser.getName()); 277 return 0; 278 } 279 long newElementId = tagParser.parseAndAdd(parser); 280 if (newElementId >= 0) { 281 // Keep track of the set of screens which need to be added to the db. 282 if (!screenIds.contains(screenId) && 283 container == Favorites.CONTAINER_DESKTOP) { 284 screenIds.add(screenId); 285 } 286 return 1; 287 } 288 return 0; 289 } 290 addShortcut(String title, Intent intent, int type)291 protected long addShortcut(String title, Intent intent, int type) { 292 long id = mCallback.generateNewItemId(); 293 mValues.put(Favorites.INTENT, intent.toUri(0)); 294 mValues.put(Favorites.TITLE, title); 295 mValues.put(Favorites.ITEM_TYPE, type); 296 mValues.put(Favorites.SPANX, 1); 297 mValues.put(Favorites.SPANY, 1); 298 mValues.put(Favorites._ID, id); 299 if (mCallback.insertAndCheck(mDb, mValues) < 0) { 300 return -1; 301 } else { 302 return id; 303 } 304 } 305 getFolderElementsMap()306 protected HashMap<String, TagParser> getFolderElementsMap() { 307 HashMap<String, TagParser> parsers = new HashMap<String, TagParser>(); 308 parsers.put(TAG_APP_ICON, new AppShortcutParser()); 309 parsers.put(TAG_AUTO_INSTALL, new AutoInstallParser()); 310 parsers.put(TAG_SHORTCUT, new ShortcutParser(mSourceRes)); 311 return parsers; 312 } 313 getLayoutElementsMap()314 protected HashMap<String, TagParser> getLayoutElementsMap() { 315 HashMap<String, TagParser> parsers = new HashMap<String, TagParser>(); 316 parsers.put(TAG_APP_ICON, new AppShortcutParser()); 317 parsers.put(TAG_AUTO_INSTALL, new AutoInstallParser()); 318 parsers.put(TAG_FOLDER, new FolderParser()); 319 parsers.put(TAG_APPWIDGET, new PendingWidgetParser()); 320 parsers.put(TAG_SHORTCUT, new ShortcutParser(mSourceRes)); 321 return parsers; 322 } 323 324 protected interface TagParser { 325 /** 326 * Parses the tag and adds to the db 327 * @return the id of the row added or -1; 328 */ parseAndAdd(XmlResourceParser parser)329 long parseAndAdd(XmlResourceParser parser) 330 throws XmlPullParserException, IOException; 331 } 332 333 /** 334 * App shortcuts: required attributes packageName and className 335 */ 336 protected class AppShortcutParser implements TagParser { 337 338 @Override parseAndAdd(XmlResourceParser parser)339 public long parseAndAdd(XmlResourceParser parser) { 340 final String packageName = getAttributeValue(parser, ATTR_PACKAGE_NAME); 341 final String className = getAttributeValue(parser, ATTR_CLASS_NAME); 342 343 if (!TextUtils.isEmpty(packageName) && !TextUtils.isEmpty(className)) { 344 ActivityInfo info; 345 try { 346 ComponentName cn; 347 try { 348 cn = new ComponentName(packageName, className); 349 info = mPackageManager.getActivityInfo(cn, 0); 350 } catch (PackageManager.NameNotFoundException nnfe) { 351 String[] packages = mPackageManager.currentToCanonicalPackageNames( 352 new String[] { packageName }); 353 cn = new ComponentName(packages[0], className); 354 info = mPackageManager.getActivityInfo(cn, 0); 355 } 356 final Intent intent = new Intent(Intent.ACTION_MAIN, null) 357 .addCategory(Intent.CATEGORY_LAUNCHER) 358 .setComponent(cn) 359 .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | 360 Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); 361 362 return addShortcut(info.loadLabel(mPackageManager).toString(), 363 intent, Favorites.ITEM_TYPE_APPLICATION); 364 } catch (PackageManager.NameNotFoundException e) { 365 Log.e(TAG, "Unable to add favorite: " + packageName + "/" + className, e); 366 } 367 return -1; 368 } else { 369 return invalidPackageOrClass(parser); 370 } 371 } 372 373 /** 374 * Helper method to allow extending the parser capabilities 375 */ invalidPackageOrClass(XmlResourceParser parser)376 protected long invalidPackageOrClass(XmlResourceParser parser) { 377 Log.w(TAG, "Skipping invalid <favorite> with no component"); 378 return -1; 379 } 380 } 381 382 /** 383 * AutoInstall: required attributes packageName and className 384 */ 385 protected class AutoInstallParser implements TagParser { 386 387 @Override parseAndAdd(XmlResourceParser parser)388 public long parseAndAdd(XmlResourceParser parser) { 389 final String packageName = getAttributeValue(parser, ATTR_PACKAGE_NAME); 390 final String className = getAttributeValue(parser, ATTR_CLASS_NAME); 391 if (TextUtils.isEmpty(packageName) || TextUtils.isEmpty(className)) { 392 if (LOGD) Log.d(TAG, "Skipping invalid <favorite> with no component"); 393 return -1; 394 } 395 396 mValues.put(Favorites.RESTORED, ShortcutInfo.FLAG_AUTOINTALL_ICON); 397 final Intent intent = new Intent(Intent.ACTION_MAIN, null) 398 .addCategory(Intent.CATEGORY_LAUNCHER) 399 .setComponent(new ComponentName(packageName, className)) 400 .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | 401 Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); 402 return addShortcut(mContext.getString(R.string.package_state_unknown), intent, 403 Favorites.ITEM_TYPE_APPLICATION); 404 } 405 } 406 407 /** 408 * Parses a web shortcut. Required attributes url, icon, title 409 */ 410 protected class ShortcutParser implements TagParser { 411 412 private final Resources mIconRes; 413 ShortcutParser(Resources iconRes)414 public ShortcutParser(Resources iconRes) { 415 mIconRes = iconRes; 416 } 417 418 @Override parseAndAdd(XmlResourceParser parser)419 public long parseAndAdd(XmlResourceParser parser) { 420 final int titleResId = getAttributeResourceValue(parser, ATTR_TITLE, 0); 421 final int iconId = getAttributeResourceValue(parser, ATTR_ICON, 0); 422 423 if (titleResId == 0 || iconId == 0) { 424 if (LOGD) Log.d(TAG, "Ignoring shortcut"); 425 return -1; 426 } 427 428 final Intent intent = parseIntent(parser); 429 if (intent == null) { 430 return -1; 431 } 432 433 Drawable icon = mIconRes.getDrawable(iconId); 434 if (icon == null) { 435 if (LOGD) Log.d(TAG, "Ignoring shortcut, can't load icon"); 436 return -1; 437 } 438 439 ItemInfo.writeBitmap(mValues, Utilities.createIconBitmap(icon, mContext)); 440 mValues.put(Favorites.ICON_PACKAGE, mIconRes.getResourcePackageName(iconId)); 441 mValues.put(Favorites.ICON_RESOURCE, mIconRes.getResourceName(iconId)); 442 443 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | 444 Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); 445 return addShortcut(mSourceRes.getString(titleResId), 446 intent, Favorites.ITEM_TYPE_SHORTCUT); 447 } 448 parseIntent(XmlResourceParser parser)449 protected Intent parseIntent(XmlResourceParser parser) { 450 final String url = getAttributeValue(parser, ATTR_URL); 451 if (TextUtils.isEmpty(url) || !Patterns.WEB_URL.matcher(url).matches()) { 452 if (LOGD) Log.d(TAG, "Ignoring shortcut, invalid url: " + url); 453 return null; 454 } 455 return new Intent(Intent.ACTION_VIEW, null).setData(Uri.parse(url)); 456 } 457 } 458 459 /** 460 * AppWidget parser: Required attributes packageName, className, spanX and spanY. 461 * Options child nodes: <extra key=... value=... /> 462 * It adds a pending widget which allows the widget to come later. If there are extras, those 463 * are passed to widget options during bind. 464 * The config activity for the widget (if present) is not shown, so any optional configurations 465 * should be passed as extras and the widget should support reading these widget options. 466 */ 467 protected class PendingWidgetParser implements TagParser { 468 469 @Override parseAndAdd(XmlResourceParser parser)470 public long parseAndAdd(XmlResourceParser parser) 471 throws XmlPullParserException, IOException { 472 final String packageName = getAttributeValue(parser, ATTR_PACKAGE_NAME); 473 final String className = getAttributeValue(parser, ATTR_CLASS_NAME); 474 if (TextUtils.isEmpty(packageName) || TextUtils.isEmpty(className)) { 475 if (LOGD) Log.d(TAG, "Skipping invalid <appwidget> with no component"); 476 return -1; 477 } 478 479 mValues.put(Favorites.SPANX, getAttributeValue(parser, ATTR_SPAN_X)); 480 mValues.put(Favorites.SPANY, getAttributeValue(parser, ATTR_SPAN_Y)); 481 mValues.put(Favorites.ITEM_TYPE, Favorites.ITEM_TYPE_APPWIDGET); 482 483 // Read the extras 484 Bundle extras = new Bundle(); 485 int widgetDepth = parser.getDepth(); 486 int type; 487 while ((type = parser.next()) != XmlPullParser.END_TAG || 488 parser.getDepth() > widgetDepth) { 489 if (type != XmlPullParser.START_TAG) { 490 continue; 491 } 492 493 if (TAG_EXTRA.equals(parser.getName())) { 494 String key = getAttributeValue(parser, ATTR_KEY); 495 String value = getAttributeValue(parser, ATTR_VALUE); 496 if (key != null && value != null) { 497 extras.putString(key, value); 498 } else { 499 throw new RuntimeException("Widget extras must have a key and value"); 500 } 501 } else { 502 throw new RuntimeException("Widgets can contain only extras"); 503 } 504 } 505 506 return verifyAndInsert(new ComponentName(packageName, className), extras); 507 } 508 verifyAndInsert(ComponentName cn, Bundle extras)509 protected long verifyAndInsert(ComponentName cn, Bundle extras) { 510 mValues.put(Favorites.APPWIDGET_PROVIDER, cn.flattenToString()); 511 mValues.put(Favorites.RESTORED, 512 LauncherAppWidgetInfo.FLAG_ID_NOT_VALID | 513 LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY | 514 LauncherAppWidgetInfo.FLAG_DIRECT_CONFIG); 515 mValues.put(Favorites._ID, mCallback.generateNewItemId()); 516 if (!extras.isEmpty()) { 517 mValues.put(Favorites.INTENT, new Intent().putExtras(extras).toUri(0)); 518 } 519 520 long insertedId = mCallback.insertAndCheck(mDb, mValues); 521 if (insertedId < 0) { 522 return -1; 523 } else { 524 return insertedId; 525 } 526 } 527 } 528 529 protected class FolderParser implements TagParser { 530 private final HashMap<String, TagParser> mFolderElements; 531 FolderParser()532 public FolderParser() { 533 this(getFolderElementsMap()); 534 } 535 FolderParser(HashMap<String, TagParser> elements)536 public FolderParser(HashMap<String, TagParser> elements) { 537 mFolderElements = elements; 538 } 539 540 @Override parseAndAdd(XmlResourceParser parser)541 public long parseAndAdd(XmlResourceParser parser) 542 throws XmlPullParserException, IOException { 543 final String title; 544 final int titleResId = getAttributeResourceValue(parser, ATTR_TITLE, 0); 545 if (titleResId != 0) { 546 title = mSourceRes.getString(titleResId); 547 } else { 548 title = mContext.getResources().getString(R.string.folder_name); 549 } 550 551 mValues.put(Favorites.TITLE, title); 552 mValues.put(Favorites.ITEM_TYPE, Favorites.ITEM_TYPE_FOLDER); 553 mValues.put(Favorites.SPANX, 1); 554 mValues.put(Favorites.SPANY, 1); 555 mValues.put(Favorites._ID, mCallback.generateNewItemId()); 556 long folderId = mCallback.insertAndCheck(mDb, mValues); 557 if (folderId < 0) { 558 if (LOGD) Log.e(TAG, "Unable to add folder"); 559 return -1; 560 } 561 562 final ContentValues myValues = new ContentValues(mValues); 563 ArrayList<Long> folderItems = new ArrayList<Long>(); 564 565 int type; 566 int folderDepth = parser.getDepth(); 567 int rank = 0; 568 while ((type = parser.next()) != XmlPullParser.END_TAG || 569 parser.getDepth() > folderDepth) { 570 if (type != XmlPullParser.START_TAG) { 571 continue; 572 } 573 mValues.clear(); 574 mValues.put(Favorites.CONTAINER, folderId); 575 mValues.put(Favorites.RANK, rank); 576 577 TagParser tagParser = mFolderElements.get(parser.getName()); 578 if (tagParser != null) { 579 final long id = tagParser.parseAndAdd(parser); 580 if (id >= 0) { 581 folderItems.add(id); 582 rank++; 583 } 584 } else { 585 throw new RuntimeException("Invalid folder item " + parser.getName()); 586 } 587 } 588 589 long addedId = folderId; 590 591 // We can only have folders with >= 2 items, so we need to remove the 592 // folder and clean up if less than 2 items were included, or some 593 // failed to add, and less than 2 were actually added 594 if (folderItems.size() < 2) { 595 // Delete the folder 596 Uri uri = Favorites.getContentUri(folderId); 597 SqlArguments args = new SqlArguments(uri, null, null); 598 mDb.delete(args.table, args.where, args.args); 599 addedId = -1; 600 601 // If we have a single item, promote it to where the folder 602 // would have been. 603 if (folderItems.size() == 1) { 604 final ContentValues childValues = new ContentValues(); 605 copyInteger(myValues, childValues, Favorites.CONTAINER); 606 copyInteger(myValues, childValues, Favorites.SCREEN); 607 copyInteger(myValues, childValues, Favorites.CELLX); 608 copyInteger(myValues, childValues, Favorites.CELLY); 609 610 addedId = folderItems.get(0); 611 mDb.update(Favorites.TABLE_NAME, childValues, 612 Favorites._ID + "=" + addedId, null); 613 } 614 } 615 return addedId; 616 } 617 } 618 beginDocument(XmlPullParser parser, String firstElementName)619 protected static final void beginDocument(XmlPullParser parser, String firstElementName) 620 throws XmlPullParserException, IOException { 621 int type; 622 while ((type = parser.next()) != XmlPullParser.START_TAG 623 && type != XmlPullParser.END_DOCUMENT); 624 625 if (type != XmlPullParser.START_TAG) { 626 throw new XmlPullParserException("No start tag found"); 627 } 628 629 if (!parser.getName().equals(firstElementName)) { 630 throw new XmlPullParserException("Unexpected start tag: found " + parser.getName() + 631 ", expected " + firstElementName); 632 } 633 } 634 convertToDistanceFromEnd(String value, int endValue)635 private static String convertToDistanceFromEnd(String value, int endValue) { 636 if (!TextUtils.isEmpty(value)) { 637 int x = Integer.parseInt(value); 638 if (x < 0) { 639 return Integer.toString(endValue + x); 640 } 641 } 642 return value; 643 } 644 645 /** 646 * Return attribute value, attempting launcher-specific namespace first 647 * before falling back to anonymous attribute. 648 */ getAttributeValue(XmlResourceParser parser, String attribute)649 protected static String getAttributeValue(XmlResourceParser parser, String attribute) { 650 String value = parser.getAttributeValue( 651 "http://schemas.android.com/apk/res-auto/com.android.launcher3", attribute); 652 if (value == null) { 653 value = parser.getAttributeValue(null, attribute); 654 } 655 return value; 656 } 657 658 /** 659 * Return attribute resource value, attempting launcher-specific namespace 660 * first before falling back to anonymous attribute. 661 */ getAttributeResourceValue(XmlResourceParser parser, String attribute, int defaultValue)662 protected static int getAttributeResourceValue(XmlResourceParser parser, String attribute, 663 int defaultValue) { 664 int value = parser.getAttributeResourceValue( 665 "http://schemas.android.com/apk/res-auto/com.android.launcher3", attribute, 666 defaultValue); 667 if (value == defaultValue) { 668 value = parser.getAttributeResourceValue(null, attribute, defaultValue); 669 } 670 return value; 671 } 672 673 public static interface LayoutParserCallback { generateNewItemId()674 long generateNewItemId(); 675 insertAndCheck(SQLiteDatabase db, ContentValues values)676 long insertAndCheck(SQLiteDatabase db, ContentValues values); 677 } 678 copyInteger(ContentValues from, ContentValues to, String key)679 @Thunk static void copyInteger(ContentValues from, ContentValues to, String key) { 680 to.put(key, from.getAsInteger(key)); 681 } 682 } 683