diff --git a/res/values-sw720dp/config.xml b/res/values-sw720dp/config.xml
index c0accb1..7c8d3d2 100644
--- a/res/values-sw720dp/config.xml
+++ b/res/values-sw720dp/config.xml
@@ -24,7 +24,7 @@
     <bool name="config_workspaceFadeAdjacentScreens">true</bool>
 
     <!-- Camera distance for the overscroll effect -->
-    <integer name="config_cameraDistance">6500</integer>
+    <integer name="config_cameraDistance">18000</integer>
 
 <!-- Hotseat -->
     <bool name="hotseat_transpose_layout_with_orientation">false</bool>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 628884f..e82f618 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -25,6 +25,7 @@
     <!-- entries for custom clings, will be set in overlays -->
     <add-resource type="dimen" name="custom_cling_margin_top" />
     <add-resource type="dimen" name="custom_cling_margin_right" />
+    <add-resource type="dimen" name="custom_cling_margin_left" />
 
 <!-- Workspace -->
     <!-- qsb_bar_height_inset represents qsb_bar_height minus the padding
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 19d363c..04e45ae 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -261,4 +261,17 @@
     <string name="folder_renamed">Folder renamed to <xliff:g id="name" example="Games">%1$s</xliff:g></string>
     <!-- Folder name format -->
     <string name="folder_name_format">Folder: <xliff:g id="name" example="Games">%1$s</xliff:g></string>
+
+    <!-- Strings used in device overlays -->
+
+    <!-- Clings -->
+    <!-- Dummy string [CHAR_LIMIT=40] -->
+    <add-resource type="string" name="custom_workspace_cling_title_1"/>
+    <!-- Dummy string [CHAR_LIMIT=60] -->
+    <add-resource type="string" name="custom_workspace_cling_description_1"/>
+    <!-- Dummy string [CHAR_LIMIT=40] -->
+    <add-resource type="string" name="custom_workspace_cling_title_2"/>
+    <!-- Dummy string [CHAR_LIMIT=60] -->
+    <add-resource type="string" name="custom_workspace_cling_description_2"/>
+
 </resources>
diff --git a/src/com/android/launcher2/Launcher.java b/src/com/android/launcher2/Launcher.java
index 700f921..6fcda8a 100644
--- a/src/com/android/launcher2/Launcher.java
+++ b/src/com/android/launcher2/Launcher.java
@@ -55,7 +55,6 @@
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.AsyncTask;
-import android.os.Build;
 import android.os.Bundle;
 import android.os.Environment;
 import android.os.Handler;
