am a4bb0b7c: am d5abe7ea: am ccd11ec5: DO NOT MERGE Increase the system-image revision number after opengl bug fix
* commit 'a4bb0b7c89f39ce04a115eb54f204fd9e3b83506':
DO NOT MERGE Increase the system-image revision number after opengl bug fix
diff --git a/samples/ApiDemos/src/com/example/android/apis/app/LoaderCursor.java b/samples/ApiDemos/src/com/example/android/apis/app/LoaderCursor.java
index f309191..4d2a4d0 100644
--- a/samples/ApiDemos/src/com/example/android/apis/app/LoaderCursor.java
+++ b/samples/ApiDemos/src/com/example/android/apis/app/LoaderCursor.java
@@ -20,6 +20,7 @@
import android.app.FragmentManager;
import android.app.ListFragment;
import android.app.LoaderManager;
+import android.content.Context;
import android.content.CursorLoader;
import android.content.Loader;
import android.database.Cursor;
@@ -34,6 +35,7 @@
import android.view.View;
import android.widget.ListView;
import android.widget.SearchView;
+import android.widget.SearchView.OnCloseListener;
import android.widget.SimpleCursorAdapter;
import android.widget.SearchView.OnQueryTextListener;
@@ -58,11 +60,15 @@
//BEGIN_INCLUDE(fragment_cursor)
public static class CursorLoaderListFragment extends ListFragment
- implements OnQueryTextListener, LoaderManager.LoaderCallbacks<Cursor> {
+ implements OnQueryTextListener, OnCloseListener,
+ LoaderManager.LoaderCallbacks<Cursor> {
// This is the Adapter being used to display the list's data.
SimpleCursorAdapter mAdapter;
+ // The SearchView for doing filtering.
+ SearchView mSearchView;
+
// If non-null, this is the current filter the user has provided.
String mCurFilter;
@@ -91,15 +97,31 @@
getLoaderManager().initLoader(0, null, this);
}
+ public static class MySearchView extends SearchView {
+ public MySearchView(Context context) {
+ super(context);
+ }
+
+ // The normal SearchView doesn't clear its search text when
+ // collapsed, so we will do this for it.
+ @Override
+ public void onActionViewCollapsed() {
+ setQuery("", false);
+ super.onActionViewCollapsed();
+ }
+ }
+
@Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
// Place an action bar item for searching.
MenuItem item = menu.add("Search");
item.setIcon(android.R.drawable.ic_menu_search);
item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM
| MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);
- SearchView sv = new SearchView(getActivity());
- sv.setOnQueryTextListener(this);
- item.setActionView(sv);
+ mSearchView = new MySearchView(getActivity());
+ mSearchView.setOnQueryTextListener(this);
+ mSearchView.setOnCloseListener(this);
+ mSearchView.setIconifiedByDefault(true);
+ item.setActionView(mSearchView);
}
public boolean onQueryTextChange(String newText) {
@@ -125,6 +147,14 @@
return true;
}
+ @Override
+ public boolean onClose() {
+ if (!TextUtils.isEmpty(mSearchView.getQuery())) {
+ mSearchView.setQuery(null, true);
+ }
+ return true;
+ }
+
@Override public void onListItemClick(ListView l, View v, int position, long id) {
// Insert desired behavior here.
Log.i("FragmentComplexList", "Item clicked: " + id);
diff --git a/samples/ApiDemos/src/com/example/android/apis/app/LoaderCustom.java b/samples/ApiDemos/src/com/example/android/apis/app/LoaderCustom.java
index 7c16fb3..ffcf890 100644
--- a/samples/ApiDemos/src/com/example/android/apis/app/LoaderCustom.java
+++ b/samples/ApiDemos/src/com/example/android/apis/app/LoaderCustom.java
@@ -17,6 +17,7 @@
package com.example.android.apis.app;
import com.example.android.apis.R;
+import com.example.android.apis.app.LoaderCursor.CursorLoaderListFragment.MySearchView;
import java.io.File;
import java.text.Collator;
@@ -55,6 +56,7 @@
import android.widget.ListView;
import android.widget.SearchView;
import android.widget.TextView;
+import android.widget.SearchView.OnCloseListener;
import android.widget.SearchView.OnQueryTextListener;
/**
@@ -397,11 +399,15 @@
}
public static class AppListFragment extends ListFragment
- implements OnQueryTextListener, LoaderManager.LoaderCallbacks<List<AppEntry>> {
+ implements OnQueryTextListener, OnCloseListener,
+ LoaderManager.LoaderCallbacks<List<AppEntry>> {
// This is the Adapter being used to display the list's data.
AppListAdapter mAdapter;
+ // The SearchView for doing filtering.
+ SearchView mSearchView;
+
// If non-null, this is the current filter the user has provided.
String mCurFilter;
@@ -427,15 +433,31 @@
getLoaderManager().initLoader(0, null, this);
}
+ public static class MySearchView extends SearchView {
+ public MySearchView(Context context) {
+ super(context);
+ }
+
+ // The normal SearchView doesn't clear its search text when
+ // collapsed, so we will do this for it.
+ @Override
+ public void onActionViewCollapsed() {
+ setQuery("", false);
+ super.onActionViewCollapsed();
+ }
+ }
+
@Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
// Place an action bar item for searching.
MenuItem item = menu.add("Search");
item.setIcon(android.R.drawable.ic_menu_search);
item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM
| MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);
- SearchView sv = new SearchView(getActivity());
- sv.setOnQueryTextListener(this);
- item.setActionView(sv);
+ mSearchView = new MySearchView(getActivity());
+ mSearchView.setOnQueryTextListener(this);
+ mSearchView.setOnCloseListener(this);
+ mSearchView.setIconifiedByDefault(true);
+ item.setActionView(mSearchView);
}
@Override public boolean onQueryTextChange(String newText) {
@@ -451,6 +473,14 @@
return true;
}
+ @Override
+ public boolean onClose() {
+ if (!TextUtils.isEmpty(mSearchView.getQuery())) {
+ mSearchView.setQuery(null, true);
+ }
+ return true;
+ }
+
@Override public void onListItemClick(ListView l, View v, int position, long id) {
// Insert desired behavior here.
Log.i("LoaderCustom", "Item clicked: " + id);
diff --git a/samples/ApiDemos/src/com/example/android/apis/app/LoaderRetained.java b/samples/ApiDemos/src/com/example/android/apis/app/LoaderRetained.java
index 521f6e5..7ddb737 100644
--- a/samples/ApiDemos/src/com/example/android/apis/app/LoaderRetained.java
+++ b/samples/ApiDemos/src/com/example/android/apis/app/LoaderRetained.java
@@ -16,10 +16,13 @@
package com.example.android.apis.app;
+import com.example.android.apis.app.LoaderCursor.CursorLoaderListFragment.MySearchView;
+
import android.app.Activity;
import android.app.FragmentManager;
import android.app.ListFragment;
import android.app.LoaderManager;
+import android.content.Context;
import android.content.CursorLoader;
import android.content.Loader;
import android.database.Cursor;
@@ -35,6 +38,7 @@
import android.widget.ListView;
import android.widget.SearchView;
import android.widget.SimpleCursorAdapter;
+import android.widget.SearchView.OnCloseListener;
import android.widget.SearchView.OnQueryTextListener;
/**
@@ -58,11 +62,15 @@
//BEGIN_INCLUDE(fragment_cursor)
public static class CursorLoaderListFragment extends ListFragment
- implements OnQueryTextListener, LoaderManager.LoaderCallbacks<Cursor> {
+ implements OnQueryTextListener, OnCloseListener,
+ LoaderManager.LoaderCallbacks<Cursor> {
// This is the Adapter being used to display the list's data.
SimpleCursorAdapter mAdapter;
+ // The SearchView for doing filtering.
+ SearchView mSearchView;
+
// If non-null, this is the current filter the user has provided.
String mCurFilter;
@@ -94,15 +102,31 @@
getLoaderManager().initLoader(0, null, this);
}
+ public static class MySearchView extends SearchView {
+ public MySearchView(Context context) {
+ super(context);
+ }
+
+ // The normal SearchView doesn't clear its search text when
+ // collapsed, so we will do this for it.
+ @Override
+ public void onActionViewCollapsed() {
+ setQuery("", false);
+ super.onActionViewCollapsed();
+ }
+ }
+
@Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
// Place an action bar item for searching.
MenuItem item = menu.add("Search");
item.setIcon(android.R.drawable.ic_menu_search);
item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM
| MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);
- SearchView sv = new SearchView(getActivity());
- sv.setOnQueryTextListener(this);
- item.setActionView(sv);
+ mSearchView = new MySearchView(getActivity());
+ mSearchView.setOnQueryTextListener(this);
+ mSearchView.setOnCloseListener(this);
+ mSearchView.setIconifiedByDefault(true);
+ item.setActionView(mSearchView);
}
public boolean onQueryTextChange(String newText) {
@@ -128,6 +152,14 @@
return true;
}
+ @Override
+ public boolean onClose() {
+ if (!TextUtils.isEmpty(mSearchView.getQuery())) {
+ mSearchView.setQuery(null, true);
+ }
+ return true;
+ }
+
@Override public void onListItemClick(ListView l, View v, int position, long id) {
// Insert desired behavior here.
Log.i("FragmentComplexList", "Item clicked: " + id);
diff --git a/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCursorSupport.java b/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCursorSupport.java
index bc74b6d..f2f9b3c 100644
--- a/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCursorSupport.java
+++ b/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCursorSupport.java
@@ -24,6 +24,7 @@
import android.support.v4.content.Loader;
import android.support.v4.view.MenuItemCompat;
import android.support.v4.widget.SearchViewCompat;
+import android.support.v4.widget.SearchViewCompat.OnCloseListenerCompat;
import android.support.v4.widget.SearchViewCompat.OnQueryTextListenerCompat;
import android.support.v4.widget.SimpleCursorAdapter;
@@ -101,7 +102,7 @@
item.setIcon(android.R.drawable.ic_menu_search);
MenuItemCompat.setShowAsAction(item, MenuItemCompat.SHOW_AS_ACTION_ALWAYS
| MenuItemCompat.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);
- View searchView = SearchViewCompat.newSearchView(getActivity());
+ final View searchView = SearchViewCompat.newSearchView(getActivity());
if (searchView != null) {
SearchViewCompat.setOnQueryTextListener(searchView,
new OnQueryTextListenerCompat() {
@@ -124,6 +125,17 @@
return true;
}
});
+ SearchViewCompat.setOnCloseListener(searchView,
+ new OnCloseListenerCompat() {
+ @Override
+ public boolean onClose() {
+ if (!TextUtils.isEmpty(SearchViewCompat.getQuery(searchView))) {
+ SearchViewCompat.setQuery(searchView, null, true);
+ }
+ return true;
+ }
+
+ });
MenuItemCompat.setActionView(item, searchView);
}
}
diff --git a/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCustomSupport.java b/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCustomSupport.java
index b735e65..312aba4 100644
--- a/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCustomSupport.java
+++ b/samples/Support4Demos/src/com/example/android/supportv4/app/LoaderCustomSupport.java
@@ -37,6 +37,7 @@
import android.support.v4.content.pm.ActivityInfoCompat;
import android.support.v4.view.MenuItemCompat;
import android.support.v4.widget.SearchViewCompat;
+import android.support.v4.widget.SearchViewCompat.OnCloseListenerCompat;
import android.support.v4.widget.SearchViewCompat.OnQueryTextListenerCompat;
import android.text.TextUtils;
import android.util.Log;
@@ -440,7 +441,7 @@
item.setIcon(android.R.drawable.ic_menu_search);
MenuItemCompat.setShowAsAction(item, MenuItemCompat.SHOW_AS_ACTION_IF_ROOM
| MenuItemCompat.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);
- View searchView = SearchViewCompat.newSearchView(getActivity());
+ final View searchView = SearchViewCompat.newSearchView(getActivity());
if (searchView != null) {
SearchViewCompat.setOnQueryTextListener(searchView,
new OnQueryTextListenerCompat() {
@@ -453,6 +454,17 @@
return true;
}
});
+ SearchViewCompat.setOnCloseListener(searchView,
+ new OnCloseListenerCompat() {
+ @Override
+ public boolean onClose() {
+ if (!TextUtils.isEmpty(SearchViewCompat.getQuery(searchView))) {
+ SearchViewCompat.setQuery(searchView, null, true);
+ }
+ return true;
+ }
+
+ });
MenuItemCompat.setActionView(item, searchView);
}
}
diff --git a/samples/training/EffectiveNavigation/libs/android-support-v4.jar b/samples/training/EffectiveNavigation/libs/android-support-v4.jar
new file mode 100644
index 0000000..4846ef9
--- /dev/null
+++ b/samples/training/EffectiveNavigation/libs/android-support-v4.jar
Binary files differ
diff --git a/samples/training/InteractiveChart/AndroidManifest.xml b/samples/training/InteractiveChart/AndroidManifest.xml
new file mode 100755
index 0000000..1e29155
--- /dev/null
+++ b/samples/training/InteractiveChart/AndroidManifest.xml
@@ -0,0 +1,42 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.example.android.interactivechart"
+ android:versionCode="1"
+ android:versionName="1.0">
+
+ <uses-sdk android:minSdkVersion="9" android:targetSdkVersion="17" />
+
+ <application
+ android:allowBackup="true"
+ android:label="@string/app_name"
+ android:description="@string/app_description"
+ android:icon="@drawable/ic_launcher"
+ android:theme="@style/AppTheme">
+
+ <activity
+ android:name=".MainActivity"
+ android:label="@string/app_name">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+
+ </application>
+
+</manifest>
diff --git a/samples/training/InteractiveChart/libs/android-support-v4.jar b/samples/training/InteractiveChart/libs/android-support-v4.jar
new file mode 100644
index 0000000..6080877
--- /dev/null
+++ b/samples/training/InteractiveChart/libs/android-support-v4.jar
Binary files differ
diff --git a/samples/training/InteractiveChart/project.properties b/samples/training/InteractiveChart/project.properties
new file mode 100755
index 0000000..7c903ad
--- /dev/null
+++ b/samples/training/InteractiveChart/project.properties
@@ -0,0 +1,27 @@
+#
+# Copyright 2013 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system use,
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+
+# Project target.
+target=android-17
diff --git a/samples/training/InteractiveChart/res/drawable-hdpi/ic_launcher.png b/samples/training/InteractiveChart/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 0000000..9e2d6ee
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-hdpi/ic_launcher.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-mdpi/ic_launcher.png b/samples/training/InteractiveChart/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 0000000..2292930
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-mdpi/ic_launcher.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_down.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_down.png
new file mode 100644
index 0000000..38c7b20
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_down.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_left.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_left.png
new file mode 100644
index 0000000..e97e910
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_left.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_right.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_right.png
new file mode 100644
index 0000000..7dc45c0
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_right.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_up.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_up.png
new file mode 100644
index 0000000..2ed3251
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_pan_up.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_zoom_in.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_zoom_in.png
new file mode 100644
index 0000000..23b9a1c
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_zoom_in.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_zoom_out.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_zoom_out.png
new file mode 100644
index 0000000..bb95274
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_action_zoom_out.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xhdpi/ic_launcher.png b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..b1e3613
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xhdpi/ic_launcher.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/drawable-xxhdpi/ic_launcher.png b/samples/training/InteractiveChart/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..2217834
--- /dev/null
+++ b/samples/training/InteractiveChart/res/drawable-xxhdpi/ic_launcher.png
Binary files differ
diff --git a/samples/training/InteractiveChart/res/layout/activity_main.xml b/samples/training/InteractiveChart/res/layout/activity_main.xml
new file mode 100755
index 0000000..285d8ae
--- /dev/null
+++ b/samples/training/InteractiveChart/res/layout/activity_main.xml
@@ -0,0 +1,32 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<com.example.android.interactivechart.InteractiveLineGraphView
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:app="http://schemas.android.com/apk/res/com.example.android.interactivechart"
+ android:id="@+id/chart"
+ android:padding="@dimen/chart_padding"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ app:labelSeparation="10dp"
+ app:labelTextSize="14sp"
+ app:labelTextColor="#d000"
+ app:axisThickness="2dp"
+ app:axisColor="#d000"
+ app:gridThickness="1dp"
+ app:gridColor="#2000"
+ app:dataColor="#a6c"
+ app:dataThickness="8dp" />
diff --git a/samples/training/InteractiveChart/res/menu/main.xml b/samples/training/InteractiveChart/res/menu/main.xml
new file mode 100644
index 0000000..ad758e5
--- /dev/null
+++ b/samples/training/InteractiveChart/res/menu/main.xml
@@ -0,0 +1,43 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+ <item android:id="@+id/action_zoom_in"
+ android:icon="@drawable/ic_action_zoom_in"
+ android:title="@string/action_zoom_in"
+ android:showAsAction="never" />
+ <item android:id="@+id/action_zoom_out"
+ android:icon="@drawable/ic_action_zoom_out"
+ android:title="@string/action_zoom_out"
+ android:showAsAction="never" />
+
+ <item android:id="@+id/action_pan_left"
+ android:icon="@drawable/ic_action_pan_left"
+ android:title="@string/action_pan_left"
+ android:showAsAction="never" />
+ <item android:id="@+id/action_pan_right"
+ android:icon="@drawable/ic_action_pan_right"
+ android:title="@string/action_pan_right"
+ android:showAsAction="never" />
+ <item android:id="@+id/action_pan_up"
+ android:icon="@drawable/ic_action_pan_up"
+ android:title="@string/action_pan_up"
+ android:showAsAction="never" />
+ <item android:id="@+id/action_pan_down"
+ android:icon="@drawable/ic_action_pan_down"
+ android:title="@string/action_pan_down"
+ android:showAsAction="never" />
+</menu>
diff --git a/samples/training/InteractiveChart/res/values-sw600dp/dimens.xml b/samples/training/InteractiveChart/res/values-sw600dp/dimens.xml
new file mode 100644
index 0000000..a7073d4
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values-sw600dp/dimens.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <dimen name="chart_padding">48dp</dimen>
+</resources>
diff --git a/samples/training/InteractiveChart/res/values-v11/styles.xml b/samples/training/InteractiveChart/res/values-v11/styles.xml
new file mode 100644
index 0000000..8ff79ca
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values-v11/styles.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <style name="AppTheme" parent="@android:style/Theme.Holo.Light" />
+</resources>
diff --git a/samples/training/InteractiveChart/res/values-v14/styles.xml b/samples/training/InteractiveChart/res/values-v14/styles.xml
new file mode 100644
index 0000000..530f994
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values-v14/styles.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <style name="AppTheme" parent="@android:style/Theme.Holo.Light.DarkActionBar" />
+</resources>
diff --git a/samples/training/InteractiveChart/res/values/attrs.xml b/samples/training/InteractiveChart/res/values/attrs.xml
new file mode 100644
index 0000000..89e56cf
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values/attrs.xml
@@ -0,0 +1,29 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <declare-styleable name="InteractiveLineGraphView">
+ <attr name="labelTextSize" format="dimension" />
+ <attr name="labelTextColor" format="color" />
+ <attr name="labelSeparation" format="dimension" />
+ <attr name="axisThickness" format="dimension" />
+ <attr name="axisColor" format="color" />
+ <attr name="dataThickness" format="dimension" />
+ <attr name="dataColor" format="color" />
+ <attr name="gridThickness" format="dimension" />
+ <attr name="gridColor" format="color" />
+ </declare-styleable>
+</resources>
diff --git a/samples/training/InteractiveChart/res/values/dimens.xml b/samples/training/InteractiveChart/res/values/dimens.xml
new file mode 100644
index 0000000..51561fd
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values/dimens.xml
@@ -0,0 +1,20 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <dimen name="chart_padding">16dp</dimen>
+ <dimen name="min_chart_size">100dp</dimen>
+</resources>
diff --git a/samples/training/InteractiveChart/res/values/strings.xml b/samples/training/InteractiveChart/res/values/strings.xml
new file mode 100755
index 0000000..b08da58
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values/strings.xml
@@ -0,0 +1,26 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <string name="app_name">Interactive Chart Demo</string>
+ <string name="app_description">A sample application that allows you to navigate a simple line graph using touch gestures.</string>
+ <string name="action_zoom_in">Demo zoom in</string>
+ <string name="action_zoom_out">Demo zoom out</string>
+ <string name="action_pan_left">Demo pan left</string>
+ <string name="action_pan_right">Demo pan right</string>
+ <string name="action_pan_up">Demo pan up</string>
+ <string name="action_pan_down">Demo pan down</string>
+</resources>
diff --git a/samples/training/InteractiveChart/res/values/styles.xml b/samples/training/InteractiveChart/res/values/styles.xml
new file mode 100644
index 0000000..ccb9f7e
--- /dev/null
+++ b/samples/training/InteractiveChart/res/values/styles.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright 2013 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+<resources>
+ <style name="AppTheme" parent="@android:style/Theme.Light" />
+</resources>
diff --git a/samples/training/InteractiveChart/src/com/example/android/interactivechart/InteractiveLineGraphView.java b/samples/training/InteractiveChart/src/com/example/android/interactivechart/InteractiveLineGraphView.java
new file mode 100644
index 0000000..9407cbc
--- /dev/null
+++ b/samples/training/InteractiveChart/src/com/example/android/interactivechart/InteractiveLineGraphView.java
@@ -0,0 +1,1185 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.interactivechart;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.v4.os.ParcelableCompat;
+import android.support.v4.os.ParcelableCompatCreatorCallbacks;
+import android.support.v4.view.GestureDetectorCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.widget.EdgeEffectCompat;
+import android.util.AttributeSet;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.ScaleGestureDetector;
+import android.view.View;
+import android.widget.OverScroller;
+
+/**
+ * A view representing a simple yet interactive line chart for the function <code>x^3 - x/4</code>.
+ * <p>
+ * This view isn't all that useful on its own; rather it serves as an example of how to correctly
+ * implement these types of gestures to perform zooming and scrolling with interesting content
+ * types.
+ * <p>
+ * The view is interactive in that it can be zoomed and panned using
+ * typical <a href="http://developer.android.com/design/patterns/gestures.html">gestures</a> such
+ * as double-touch, drag, pinch-open, and pinch-close. This is done using the
+ * {@link ScaleGestureDetector}, {@link GestureDetector}, and {@link OverScroller} classes. Note
+ * that the platform-provided view scrolling behavior (e.g. {@link View#scrollBy(int, int)} is NOT
+ * used.
+ * <p>
+ * The view also demonstrates the correct use of
+ * <a href="http://developer.android.com/design/style/touch-feedback.html">touch feedback</a> to
+ * indicate to users that they've reached the content edges after a pan or fling gesture. This
+ * is done using the {@link EdgeEffectCompat} class.
+ * <p>
+ * Finally, this class demonstrates the basics of creating a custom view, including support for
+ * custom attributes (see the constructors), a simple implementation for
+ * {@link #onMeasure(int, int)}, an implementation for {@link #onSaveInstanceState()} and a fairly
+ * straightforward {@link Canvas}-based rendering implementation in
+ * {@link #onDraw(android.graphics.Canvas)}.
+ * <p>
+ * Note that this view doesn't automatically support directional navigation or other accessibility
+ * methods. Activities using this view should generally provide alternate navigation controls.
+ * Activities using this view should also present an alternate, text-based representation of this
+ * view's content for vision-impaired users.
+ */
+public class InteractiveLineGraphView extends View {
+ private static final String TAG = "InteractiveLineGraphView";
+
+ /**
+ * The number of individual points (samples) in the chart series to draw onscreen.
+ */
+ private static final int DRAW_STEPS = 30;
+
+ /**
+ * Initial fling velocity for pan operations, in screen widths (or heights) per second.
+ *
+ * @see #panLeft()
+ * @see #panRight()
+ * @see #panUp()
+ * @see #panDown()
+ */
+ private static final float PAN_VELOCITY_FACTOR = 2f;
+
+ /**
+ * The scaling factor for a single zoom 'step'.
+ *
+ * @see #zoomIn()
+ * @see #zoomOut()
+ */
+ private static final float ZOOM_AMOUNT = 0.25f;
+
+ // Viewport extremes. See mCurrentViewport for a discussion of the viewport.
+ private static final float AXIS_X_MIN = -1f;
+ private static final float AXIS_X_MAX = 1f;
+ private static final float AXIS_Y_MIN = -1f;
+ private static final float AXIS_Y_MAX = 1f;
+
+ /**
+ * The current viewport. This rectangle represents the currently visible chart domain
+ * and range. The currently visible chart X values are from this rectangle's left to its right.
+ * The currently visible chart Y values are from this rectangle's top to its bottom.
+ * <p>
+ * Note that this rectangle's top is actually the smaller Y value, and its bottom is the larger
+ * Y value. Since the chart is drawn onscreen in such a way that chart Y values increase
+ * towards the top of the screen (decreasing pixel Y positions), this rectangle's "top" is drawn
+ * above this rectangle's "bottom" value.
+ *
+ * @see #mContentRect
+ */
+ private RectF mCurrentViewport = new RectF(AXIS_X_MIN, AXIS_Y_MIN, AXIS_X_MAX, AXIS_Y_MAX);
+
+ /**
+ * The current destination rectangle (in pixel coordinates) into which the chart data should
+ * be drawn. Chart labels are drawn outside this area.
+ *
+ * @see #mCurrentViewport
+ */
+ private Rect mContentRect = new Rect();
+
+ // Current attribute values and Paints.
+ private float mLabelTextSize;
+ private int mLabelSeparation;
+ private int mLabelTextColor;
+ private Paint mLabelTextPaint;
+ private int mMaxLabelWidth;
+ private int mLabelHeight;
+ private float mGridThickness;
+ private int mGridColor;
+ private Paint mGridPaint;
+ private float mAxisThickness;
+ private int mAxisColor;
+ private Paint mAxisPaint;
+ private float mDataThickness;
+ private int mDataColor;
+ private Paint mDataPaint;
+
+ // State objects and values related to gesture tracking.
+ private ScaleGestureDetector mScaleGestureDetector;
+ private GestureDetectorCompat mGestureDetector;
+ private OverScroller mScroller;
+ private Zoomer mZoomer;
+ private PointF mZoomFocalPoint = new PointF();
+ private RectF mScrollerStartViewport = new RectF(); // Used only for zooms and flings.
+
+ // Edge effect / overscroll tracking objects.
+ private EdgeEffectCompat mEdgeEffectTop;
+ private EdgeEffectCompat mEdgeEffectBottom;
+ private EdgeEffectCompat mEdgeEffectLeft;
+ private EdgeEffectCompat mEdgeEffectRight;
+
+ private boolean mEdgeEffectTopActive;
+ private boolean mEdgeEffectBottomActive;
+ private boolean mEdgeEffectLeftActive;
+ private boolean mEdgeEffectRightActive;
+
+ // Buffers for storing current X and Y stops. See the computeAxisStops method for more details.
+ private final AxisStops mXStopsBuffer = new AxisStops();
+ private final AxisStops mYStopsBuffer = new AxisStops();
+
+ // Buffers used during drawing. These are defined as fields to avoid allocation during
+ // draw calls.
+ private float[] mAxisXPositionsBuffer = new float[]{};
+ private float[] mAxisYPositionsBuffer = new float[]{};
+ private float[] mAxisXLinesBuffer = new float[]{};
+ private float[] mAxisYLinesBuffer = new float[]{};
+ private float[] mSeriesLinesBuffer = new float[(DRAW_STEPS + 1) * 4];
+ private final char[] mLabelBuffer = new char[100];
+ private Point mSurfaceSizeBuffer = new Point();
+
+ /**
+ * The simple math function Y = fun(X) to draw on the chart.
+ * @param x The X value
+ * @return The Y value
+ */
+ protected static float fun(float x) {
+ return (float) Math.pow(x, 3) - x / 4;
+ }
+
+ public InteractiveLineGraphView(Context context) {
+ this(context, null, 0);
+ }
+
+ public InteractiveLineGraphView(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public InteractiveLineGraphView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+
+ TypedArray a = context.getTheme().obtainStyledAttributes(
+ attrs, R.styleable.InteractiveLineGraphView, defStyle, defStyle);
+
+ try {
+ mLabelTextColor = a.getColor(
+ R.styleable.InteractiveLineGraphView_labelTextColor, mLabelTextColor);
+ mLabelTextSize = a.getDimension(
+ R.styleable.InteractiveLineGraphView_labelTextSize, mLabelTextSize);
+ mLabelSeparation = a.getDimensionPixelSize(
+ R.styleable.InteractiveLineGraphView_labelSeparation, mLabelSeparation);
+
+ mGridThickness = a.getDimension(
+ R.styleable.InteractiveLineGraphView_gridThickness, mGridThickness);
+ mGridColor = a.getColor(
+ R.styleable.InteractiveLineGraphView_gridColor, mGridColor);
+
+ mAxisThickness = a.getDimension(
+ R.styleable.InteractiveLineGraphView_axisThickness, mAxisThickness);
+ mAxisColor = a.getColor(
+ R.styleable.InteractiveLineGraphView_axisColor, mAxisColor);
+
+ mDataThickness = a.getDimension(
+ R.styleable.InteractiveLineGraphView_dataThickness, mDataThickness);
+ mDataColor = a.getColor(
+ R.styleable.InteractiveLineGraphView_dataColor, mDataColor);
+ } finally {
+ a.recycle();
+ }
+
+ initPaints();
+
+ // Sets up interactions
+ mScaleGestureDetector = new ScaleGestureDetector(context, mScaleGestureListener);
+ mGestureDetector = new GestureDetectorCompat(context, mGestureListener);
+
+ mScroller = new OverScroller(context);
+ mZoomer = new Zoomer(context);
+
+ // Sets up edge effects
+ mEdgeEffectLeft = new EdgeEffectCompat(context);
+ mEdgeEffectTop = new EdgeEffectCompat(context);
+ mEdgeEffectRight = new EdgeEffectCompat(context);
+ mEdgeEffectBottom = new EdgeEffectCompat(context);
+ }
+
+ /**
+ * (Re)initializes {@link Paint} objects based on current attribute values.
+ */
+ private void initPaints() {
+ mLabelTextPaint = new Paint();
+ mLabelTextPaint.setAntiAlias(true);
+ mLabelTextPaint.setTextSize(mLabelTextSize);
+ mLabelTextPaint.setColor(mLabelTextColor);
+ mLabelHeight = (int) Math.abs(mLabelTextPaint.getFontMetrics().top);
+ mMaxLabelWidth = (int) mLabelTextPaint.measureText("0000");
+
+ mGridPaint = new Paint();
+ mGridPaint.setStrokeWidth(mGridThickness);
+ mGridPaint.setColor(mGridColor);
+ mGridPaint.setStyle(Paint.Style.STROKE);
+
+ mAxisPaint = new Paint();
+ mAxisPaint.setStrokeWidth(mAxisThickness);
+ mAxisPaint.setColor(mAxisColor);
+ mAxisPaint.setStyle(Paint.Style.STROKE);
+
+ mDataPaint = new Paint();
+ mDataPaint.setStrokeWidth(mDataThickness);
+ mDataPaint.setColor(mDataColor);
+ mDataPaint.setStyle(Paint.Style.STROKE);
+ mDataPaint.setAntiAlias(true);
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ mContentRect.set(
+ getPaddingLeft() + mMaxLabelWidth + mLabelSeparation,
+ getPaddingTop(),
+ getWidth() - getPaddingRight(),
+ getHeight() - getPaddingBottom() - mLabelHeight - mLabelSeparation);
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ int minChartSize = getResources().getDimensionPixelSize(R.dimen.min_chart_size);
+ setMeasuredDimension(
+ Math.max(getSuggestedMinimumWidth(),
+ resolveSize(minChartSize + getPaddingLeft() + mMaxLabelWidth
+ + mLabelSeparation + getPaddingRight(),
+ widthMeasureSpec)),
+ Math.max(getSuggestedMinimumHeight(),
+ resolveSize(minChartSize + getPaddingTop() + mLabelHeight
+ + mLabelSeparation + getPaddingBottom(),
+ heightMeasureSpec)));
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Methods and objects related to drawing
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ // Draws axes and text labels
+ drawAxes(canvas);
+
+ // Clips the next few drawing operations to the content area
+ int clipRestoreCount = canvas.save();
+ canvas.clipRect(mContentRect);
+
+ drawDataSeriesUnclipped(canvas);
+ drawEdgeEffectsUnclipped(canvas);
+
+ // Removes clipping rectangle
+ canvas.restoreToCount(clipRestoreCount);
+
+ // Draws chart container
+ canvas.drawRect(mContentRect, mAxisPaint);
+ }
+
+ /**
+ * Draws the chart axes and labels onto the canvas.
+ */
+ private void drawAxes(Canvas canvas) {
+ // Computes axis stops (in terms of numerical value and position on screen)
+ int i;
+
+ computeAxisStops(
+ mCurrentViewport.left,
+ mCurrentViewport.right,
+ mContentRect.width() / mMaxLabelWidth / 2,
+ mXStopsBuffer);
+ computeAxisStops(
+ mCurrentViewport.top,
+ mCurrentViewport.bottom,
+ mContentRect.height() / mLabelHeight / 2,
+ mYStopsBuffer);
+
+ // Avoid unnecessary allocations during drawing. Re-use allocated
+ // arrays and only reallocate if the number of stops grows.
+ if (mAxisXPositionsBuffer.length < mXStopsBuffer.numStops) {
+ mAxisXPositionsBuffer = new float[mXStopsBuffer.numStops];
+ }
+ if (mAxisYPositionsBuffer.length < mYStopsBuffer.numStops) {
+ mAxisYPositionsBuffer = new float[mYStopsBuffer.numStops];
+ }
+ if (mAxisXLinesBuffer.length < mXStopsBuffer.numStops * 4) {
+ mAxisXLinesBuffer = new float[mXStopsBuffer.numStops * 4];
+ }
+ if (mAxisYLinesBuffer.length < mYStopsBuffer.numStops * 4) {
+ mAxisYLinesBuffer = new float[mYStopsBuffer.numStops * 4];
+ }
+
+ // Compute positions
+ for (i = 0; i < mXStopsBuffer.numStops; i++) {
+ mAxisXPositionsBuffer[i] = getDrawX(mXStopsBuffer.stops[i]);
+ }
+ for (i = 0; i < mYStopsBuffer.numStops; i++) {
+ mAxisYPositionsBuffer[i] = getDrawY(mYStopsBuffer.stops[i]);
+ }
+
+ // Draws grid lines using drawLines (faster than individual drawLine calls)
+ for (i = 0; i < mXStopsBuffer.numStops; i++) {
+ mAxisXLinesBuffer[i * 4 + 0] = (float) Math.floor(mAxisXPositionsBuffer[i]);
+ mAxisXLinesBuffer[i * 4 + 1] = mContentRect.top;
+ mAxisXLinesBuffer[i * 4 + 2] = (float) Math.floor(mAxisXPositionsBuffer[i]);
+ mAxisXLinesBuffer[i * 4 + 3] = mContentRect.bottom;
+ }
+ canvas.drawLines(mAxisXLinesBuffer, 0, mXStopsBuffer.numStops * 4, mGridPaint);
+
+ for (i = 0; i < mYStopsBuffer.numStops; i++) {
+ mAxisYLinesBuffer[i * 4 + 0] = mContentRect.left;
+ mAxisYLinesBuffer[i * 4 + 1] = (float) Math.floor(mAxisYPositionsBuffer[i]);
+ mAxisYLinesBuffer[i * 4 + 2] = mContentRect.right;
+ mAxisYLinesBuffer[i * 4 + 3] = (float) Math.floor(mAxisYPositionsBuffer[i]);
+ }
+ canvas.drawLines(mAxisYLinesBuffer, 0, mYStopsBuffer.numStops * 4, mGridPaint);
+
+ // Draws X labels
+ int labelOffset;
+ int labelLength;
+ mLabelTextPaint.setTextAlign(Paint.Align.CENTER);
+ for (i = 0; i < mXStopsBuffer.numStops; i++) {
+ // Do not use String.format in high-performance code such as onDraw code.
+ labelLength = formatFloat(mLabelBuffer, mXStopsBuffer.stops[i], mXStopsBuffer.decimals);
+ labelOffset = mLabelBuffer.length - labelLength;
+ canvas.drawText(
+ mLabelBuffer, labelOffset, labelLength,
+ mAxisXPositionsBuffer[i],
+ mContentRect.bottom + mLabelHeight + mLabelSeparation,
+ mLabelTextPaint);
+ }
+
+ // Draws Y labels
+ mLabelTextPaint.setTextAlign(Paint.Align.RIGHT);
+ for (i = 0; i < mYStopsBuffer.numStops; i++) {
+ // Do not use String.format in high-performance code such as onDraw code.
+ labelLength = formatFloat(mLabelBuffer, mYStopsBuffer.stops[i], mYStopsBuffer.decimals);
+ labelOffset = mLabelBuffer.length - labelLength;
+ canvas.drawText(
+ mLabelBuffer, labelOffset, labelLength,
+ mContentRect.left - mLabelSeparation,
+ mAxisYPositionsBuffer[i] + mLabelHeight / 2,
+ mLabelTextPaint);
+ }
+ }
+
+ /**
+ * Rounds the given number to the given number of significant digits. Based on an answer on
+ * <a href="http://stackoverflow.com/questions/202302">Stack Overflow</a>.
+ */
+ private static float roundToOneSignificantFigure(double num) {
+ final float d = (float) Math.ceil((float) Math.log10(num < 0 ? -num : num));
+ final int power = 1 - (int) d;
+ final float magnitude = (float) Math.pow(10, power);
+ final long shifted = Math.round(num * magnitude);
+ return shifted / magnitude;
+ }
+
+ private static final int POW10[] = {1, 10, 100, 1000, 10000, 100000, 1000000};
+
+ /**
+ * Formats a float value to the given number of decimals. Returns the length of the string.
+ * The string begins at out.length - [return value].
+ */
+ private static int formatFloat(final char[] out, float val, int digits) {
+ boolean negative = false;
+ if (val == 0) {
+ out[out.length - 1] = '0';
+ return 1;
+ }
+ if (val < 0) {
+ negative = true;
+ val = -val;
+ }
+ if (digits > POW10.length) {
+ digits = POW10.length - 1;
+ }
+ val *= POW10[digits];
+ long lval = Math.round(val);
+ int index = out.length - 1;
+ int charCount = 0;
+ while (lval != 0 || charCount < (digits + 1)) {
+ int digit = (int) (lval % 10);
+ lval = lval / 10;
+ out[index--] = (char) (digit + '0');
+ charCount++;
+ if (charCount == digits) {
+ out[index--] = '.';
+ charCount++;
+ }
+ }
+ if (negative) {
+ out[index--] = '-';
+ charCount++;
+ }
+ return charCount;
+ }
+
+ /**
+ * Computes the set of axis labels to show given start and stop boundaries and an ideal number
+ * of stops between these boundaries.
+ *
+ * @param start The minimum extreme (e.g. the left edge) for the axis.
+ * @param stop The maximum extreme (e.g. the right edge) for the axis.
+ * @param steps The ideal number of stops to create. This should be based on available screen
+ * space; the more space there is, the more stops should be shown.
+ * @param outStops The destination {@link AxisStops} object to populate.
+ */
+ private static void computeAxisStops(float start, float stop, int steps, AxisStops outStops) {
+ double range = stop - start;
+ if (steps == 0 || range <= 0) {
+ outStops.stops = new float[]{};
+ outStops.numStops = 0;
+ return;
+ }
+
+ double rawInterval = range / steps;
+ double interval = roundToOneSignificantFigure(rawInterval);
+ double intervalMagnitude = Math.pow(10, (int) Math.log10(interval));
+ int intervalSigDigit = (int) (interval / intervalMagnitude);
+ if (intervalSigDigit > 5) {
+ // Use one order of magnitude higher, to avoid intervals like 0.9 or 90
+ interval = Math.floor(10 * intervalMagnitude);
+ }
+
+ double first = Math.ceil(start / interval) * interval;
+ double last = Math.nextUp(Math.floor(stop / interval) * interval);
+
+ double f;
+ int i;
+ int n = 0;
+ for (f = first; f <= last; f += interval) {
+ ++n;
+ }
+
+ outStops.numStops = n;
+
+ if (outStops.stops.length < n) {
+ // Ensure stops contains at least numStops elements.
+ outStops.stops = new float[n];
+ }
+
+ for (f = first, i = 0; i < n; f += interval, ++i) {
+ outStops.stops[i] = (float) f;
+ }
+
+ if (interval < 1) {
+ outStops.decimals = (int) Math.ceil(-Math.log10(interval));
+ } else {
+ outStops.decimals = 0;
+ }
+ }
+
+ /**
+ * Computes the pixel offset for the given X chart value. This may be outside the view bounds.
+ */
+ private float getDrawX(float x) {
+ return mContentRect.left
+ + mContentRect.width()
+ * (x - mCurrentViewport.left) / mCurrentViewport.width();
+ }
+
+ /**
+ * Computes the pixel offset for the given Y chart value. This may be outside the view bounds.
+ */
+ private float getDrawY(float y) {
+ return mContentRect.bottom
+ - mContentRect.height()
+ * (y - mCurrentViewport.top) / mCurrentViewport.height();
+ }
+
+ /**
+ * Draws the currently visible portion of the data series defined by {@link #fun(float)} to the
+ * canvas. This method does not clip its drawing, so users should call {@link Canvas#clipRect
+ * before calling this method.
+ */
+ private void drawDataSeriesUnclipped(Canvas canvas) {
+ mSeriesLinesBuffer[0] = mContentRect.left;
+ mSeriesLinesBuffer[1] = getDrawY(fun(mCurrentViewport.left));
+ mSeriesLinesBuffer[2] = mSeriesLinesBuffer[0];
+ mSeriesLinesBuffer[3] = mSeriesLinesBuffer[1];
+ float x;
+ for (int i = 1; i <= DRAW_STEPS; i++) {
+ mSeriesLinesBuffer[i * 4 + 0] = mSeriesLinesBuffer[(i - 1) * 4 + 2];
+ mSeriesLinesBuffer[i * 4 + 1] = mSeriesLinesBuffer[(i - 1) * 4 + 3];
+
+ x = (mCurrentViewport.left + (mCurrentViewport.width() / DRAW_STEPS * i));
+ mSeriesLinesBuffer[i * 4 + 2] = getDrawX(x);
+ mSeriesLinesBuffer[i * 4 + 3] = getDrawY(fun(x));
+ }
+ canvas.drawLines(mSeriesLinesBuffer, mDataPaint);
+ }
+
+ /**
+ * Draws the overscroll "glow" at the four edges of the chart region, if necessary. The edges
+ * of the chart region are stored in {@link #mContentRect}.
+ *
+ * @see EdgeEffectCompat
+ */
+ private void drawEdgeEffectsUnclipped(Canvas canvas) {
+ // The methods below rotate and translate the canvas as needed before drawing the glow,
+ // since EdgeEffectCompat always draws a top-glow at 0,0.
+
+ boolean needsInvalidate = false;
+
+ if (!mEdgeEffectTop.isFinished()) {
+ final int restoreCount = canvas.save();
+ canvas.translate(mContentRect.left, mContentRect.top);
+ mEdgeEffectTop.setSize(mContentRect.width(), mContentRect.height());
+ if (mEdgeEffectTop.draw(canvas)) {
+ needsInvalidate = true;
+ }
+ canvas.restoreToCount(restoreCount);
+ }
+
+ if (!mEdgeEffectBottom.isFinished()) {
+ final int restoreCount = canvas.save();
+ canvas.translate(2 * mContentRect.left - mContentRect.right, mContentRect.bottom);
+ canvas.rotate(180, mContentRect.width(), 0);
+ mEdgeEffectBottom.setSize(mContentRect.width(), mContentRect.height());
+ if (mEdgeEffectBottom.draw(canvas)) {
+ needsInvalidate = true;
+ }
+ canvas.restoreToCount(restoreCount);
+ }
+
+ if (!mEdgeEffectLeft.isFinished()) {
+ final int restoreCount = canvas.save();
+ canvas.translate(mContentRect.left, mContentRect.bottom);
+ canvas.rotate(-90, 0, 0);
+ mEdgeEffectLeft.setSize(mContentRect.height(), mContentRect.width());
+ if (mEdgeEffectLeft.draw(canvas)) {
+ needsInvalidate = true;
+ }
+ canvas.restoreToCount(restoreCount);
+ }
+
+ if (!mEdgeEffectRight.isFinished()) {
+ final int restoreCount = canvas.save();
+ canvas.translate(mContentRect.right, mContentRect.top);
+ canvas.rotate(90, 0, 0);
+ mEdgeEffectRight.setSize(mContentRect.height(), mContentRect.width());
+ if (mEdgeEffectRight.draw(canvas)) {
+ needsInvalidate = true;
+ }
+ canvas.restoreToCount(restoreCount);
+ }
+
+ if (needsInvalidate) {
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Methods and objects related to gesture handling
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Finds the chart point (i.e. within the chart's domain and range) represented by the
+ * given pixel coordinates, if that pixel is within the chart region described by
+ * {@link #mContentRect}. If the point is found, the "dest" argument is set to the point and
+ * this function returns true. Otherwise, this function returns false and "dest" is unchanged.
+ */
+ private boolean hitTest(float x, float y, PointF dest) {
+ if (!mContentRect.contains((int) x, (int) y)) {
+ return false;
+ }
+
+ dest.set(
+ mCurrentViewport.left
+ + mCurrentViewport.width()
+ * (x - mContentRect.left) / mContentRect.width(),
+ mCurrentViewport.top
+ + mCurrentViewport.height()
+ * (y - mContentRect.bottom) / -mContentRect.height());
+ return true;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ boolean retVal = mScaleGestureDetector.onTouchEvent(event);
+ retVal = mGestureDetector.onTouchEvent(event) || retVal;
+ return retVal || super.onTouchEvent(event);
+ }
+
+ /**
+ * The scale listener, used for handling multi-finger scale gestures.
+ */
+ private final ScaleGestureDetector.OnScaleGestureListener mScaleGestureListener
+ = new ScaleGestureDetector.SimpleOnScaleGestureListener() {
+ /**
+ * This is the active focal point in terms of the viewport. Could be a local
+ * variable but kept here to minimize per-frame allocations.
+ */
+ private PointF viewportFocus = new PointF();
+ private float lastSpanX;
+ private float lastSpanY;
+
+ @Override
+ public boolean onScaleBegin(ScaleGestureDetector scaleGestureDetector) {
+ lastSpanX = ScaleGestureDetectorCompat.getCurrentSpanX(scaleGestureDetector);
+ lastSpanY = ScaleGestureDetectorCompat.getCurrentSpanY(scaleGestureDetector);
+ return true;
+ }
+
+ @Override
+ public boolean onScale(ScaleGestureDetector scaleGestureDetector) {
+ float spanX = ScaleGestureDetectorCompat.getCurrentSpanX(scaleGestureDetector);
+ float spanY = ScaleGestureDetectorCompat.getCurrentSpanY(scaleGestureDetector);
+
+ float newWidth = lastSpanX / spanX * mCurrentViewport.width();
+ float newHeight = lastSpanY / spanY * mCurrentViewport.height();
+
+ float focusX = scaleGestureDetector.getFocusX();
+ float focusY = scaleGestureDetector.getFocusY();
+ hitTest(focusX, focusY, viewportFocus);
+
+ mCurrentViewport.set(
+ viewportFocus.x
+ - newWidth * (focusX - mContentRect.left)
+ / mContentRect.width(),
+ viewportFocus.y
+ - newHeight * (mContentRect.bottom - focusY)
+ / mContentRect.height(),
+ 0,
+ 0);
+ mCurrentViewport.right = mCurrentViewport.left + newWidth;
+ mCurrentViewport.bottom = mCurrentViewport.top + newHeight;
+ constrainViewport();
+ ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this);
+
+ lastSpanX = spanX;
+ lastSpanY = spanY;
+ return true;
+ }
+ };
+
+ /**
+ * Ensures that current viewport is inside the viewport extremes defined by {@link #AXIS_X_MIN},
+ * {@link #AXIS_X_MAX}, {@link #AXIS_Y_MIN} and {@link #AXIS_Y_MAX}.
+ */
+ private void constrainViewport() {
+ mCurrentViewport.left = Math.max(AXIS_X_MIN, mCurrentViewport.left);
+ mCurrentViewport.top = Math.max(AXIS_Y_MIN, mCurrentViewport.top);
+ mCurrentViewport.bottom = Math.max(Math.nextUp(mCurrentViewport.top),
+ Math.min(AXIS_Y_MAX, mCurrentViewport.bottom));
+ mCurrentViewport.right = Math.max(Math.nextUp(mCurrentViewport.left),
+ Math.min(AXIS_X_MAX, mCurrentViewport.right));
+ }
+
+ /**
+ * The gesture listener, used for handling simple gestures such as double touches, scrolls,
+ * and flings.
+ */
+ private final GestureDetector.SimpleOnGestureListener mGestureListener
+ = new GestureDetector.SimpleOnGestureListener() {
+ @Override
+ public boolean onDown(MotionEvent e) {
+ releaseEdgeEffects();
+ mScrollerStartViewport.set(mCurrentViewport);
+ mScroller.forceFinished(true);
+ ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this);
+ return true;
+ }
+
+ @Override
+ public boolean onDoubleTap(MotionEvent e) {
+ mZoomer.forceFinished(true);
+ if (hitTest(e.getX(), e.getY(), mZoomFocalPoint)) {
+ mZoomer.startZoom(ZOOM_AMOUNT);
+ }
+ ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this);
+ return true;
+ }
+
+ @Override
+ public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+ // Scrolling uses math based on the viewport (as opposed to math using pixels).
+ /**
+ * Pixel offset is the offset in screen pixels, while viewport offset is the
+ * offset within the current viewport. For additional information on surface sizes
+ * and pixel offsets, see the docs for {@link computeScrollSurfaceSize()}. For
+ * additional information about the viewport, see the comments for
+ * {@link mCurrentViewport}.
+ */
+ float viewportOffsetX = distanceX * mCurrentViewport.width() / mContentRect.width();
+ float viewportOffsetY = -distanceY * mCurrentViewport.height() / mContentRect.height();
+ computeScrollSurfaceSize(mSurfaceSizeBuffer);
+ int scrolledX = (int) (mSurfaceSizeBuffer.x
+ * (mCurrentViewport.left + viewportOffsetX - AXIS_X_MIN)
+ / (AXIS_X_MAX - AXIS_X_MIN));
+ int scrolledY = (int) (mSurfaceSizeBuffer.y
+ * (AXIS_Y_MAX - mCurrentViewport.bottom - viewportOffsetY)
+ / (AXIS_Y_MAX - AXIS_Y_MIN));
+ boolean canScrollX = mCurrentViewport.left > AXIS_X_MIN
+ || mCurrentViewport.right < AXIS_X_MAX;
+ boolean canScrollY = mCurrentViewport.top > AXIS_Y_MIN
+ || mCurrentViewport.bottom < AXIS_Y_MAX;
+ setViewportBottomLeft(
+ mCurrentViewport.left + viewportOffsetX,
+ mCurrentViewport.bottom + viewportOffsetY);
+
+ if (canScrollX && scrolledX < 0) {
+ mEdgeEffectLeft.onPull(scrolledX / (float) mContentRect.width());
+ mEdgeEffectLeftActive = true;
+ }
+ if (canScrollY && scrolledY < 0) {
+ mEdgeEffectTop.onPull(scrolledY / (float) mContentRect.height());
+ mEdgeEffectTopActive = true;
+ }
+ if (canScrollX && scrolledX > mSurfaceSizeBuffer.x - mContentRect.width()) {
+ mEdgeEffectRight.onPull((scrolledX - mSurfaceSizeBuffer.x + mContentRect.width())
+ / (float) mContentRect.width());
+ mEdgeEffectRightActive = true;
+ }
+ if (canScrollY && scrolledY > mSurfaceSizeBuffer.y - mContentRect.height()) {
+ mEdgeEffectBottom.onPull((scrolledY - mSurfaceSizeBuffer.y + mContentRect.height())
+ / (float) mContentRect.height());
+ mEdgeEffectBottomActive = true;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+ fling((int) -velocityX, (int) -velocityY);
+ return true;
+ }
+ };
+
+ private void releaseEdgeEffects() {
+ mEdgeEffectLeftActive
+ = mEdgeEffectTopActive
+ = mEdgeEffectRightActive
+ = mEdgeEffectBottomActive
+ = false;
+ mEdgeEffectLeft.onRelease();
+ mEdgeEffectTop.onRelease();
+ mEdgeEffectRight.onRelease();
+ mEdgeEffectBottom.onRelease();
+ }
+
+ private void fling(int velocityX, int velocityY) {
+ releaseEdgeEffects();
+ // Flings use math in pixels (as opposed to math based on the viewport).
+ computeScrollSurfaceSize(mSurfaceSizeBuffer);
+ mScrollerStartViewport.set(mCurrentViewport);
+ int startX = (int) (mSurfaceSizeBuffer.x * (mScrollerStartViewport.left - AXIS_X_MIN) / (
+ AXIS_X_MAX - AXIS_X_MIN));
+ int startY = (int) (mSurfaceSizeBuffer.y * (AXIS_Y_MAX - mScrollerStartViewport.bottom) / (
+ AXIS_Y_MAX - AXIS_Y_MIN));
+ mScroller.forceFinished(true);
+ mScroller.fling(
+ startX,
+ startY,
+ velocityX,
+ velocityY,
+ 0, mSurfaceSizeBuffer.x - mContentRect.width(),
+ 0, mSurfaceSizeBuffer.y - mContentRect.height(),
+ mContentRect.width() / 2,
+ mContentRect.height() / 2);
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ /**
+ * Computes the current scrollable surface size, in pixels. For example, if the entire chart
+ * area is visible, this is simply the current size of {@link #mContentRect}. If the chart
+ * is zoomed in 200% in both directions, the returned size will be twice as large horizontally
+ * and vertically.
+ */
+ private void computeScrollSurfaceSize(Point out) {
+ out.set(
+ (int) (mContentRect.width() * (AXIS_X_MAX - AXIS_X_MIN)
+ / mCurrentViewport.width()),
+ (int) (mContentRect.height() * (AXIS_Y_MAX - AXIS_Y_MIN)
+ / mCurrentViewport.height()));
+ }
+
+ @Override
+ public void computeScroll() {
+ super.computeScroll();
+
+ boolean needsInvalidate = false;
+
+ if (mScroller.computeScrollOffset()) {
+ // The scroller isn't finished, meaning a fling or programmatic pan operation is
+ // currently active.
+
+ computeScrollSurfaceSize(mSurfaceSizeBuffer);
+ int currX = mScroller.getCurrX();
+ int currY = mScroller.getCurrY();
+
+ boolean canScrollX = (mCurrentViewport.left > AXIS_X_MIN
+ || mCurrentViewport.right < AXIS_X_MAX);
+ boolean canScrollY = (mCurrentViewport.top > AXIS_Y_MIN
+ || mCurrentViewport.bottom < AXIS_Y_MAX);
+
+ if (canScrollX
+ && currX < 0
+ && mEdgeEffectLeft.isFinished()
+ && !mEdgeEffectLeftActive) {
+ mEdgeEffectLeft.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller));
+ mEdgeEffectLeftActive = true;
+ needsInvalidate = true;
+ } else if (canScrollX
+ && currX > (mSurfaceSizeBuffer.x - mContentRect.width())
+ && mEdgeEffectRight.isFinished()
+ && !mEdgeEffectRightActive) {
+ mEdgeEffectRight.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller));
+ mEdgeEffectRightActive = true;
+ needsInvalidate = true;
+ }
+
+ if (canScrollY
+ && currY < 0
+ && mEdgeEffectTop.isFinished()
+ && !mEdgeEffectTopActive) {
+ mEdgeEffectTop.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller));
+ mEdgeEffectTopActive = true;
+ needsInvalidate = true;
+ } else if (canScrollY
+ && currY > (mSurfaceSizeBuffer.y - mContentRect.height())
+ && mEdgeEffectBottom.isFinished()
+ && !mEdgeEffectBottomActive) {
+ mEdgeEffectBottom.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller));
+ mEdgeEffectBottomActive = true;
+ needsInvalidate = true;
+ }
+
+ float currXRange = AXIS_X_MIN + (AXIS_X_MAX - AXIS_X_MIN)
+ * currX / mSurfaceSizeBuffer.x;
+ float currYRange = AXIS_Y_MAX - (AXIS_Y_MAX - AXIS_Y_MIN)
+ * currY / mSurfaceSizeBuffer.y;
+ setViewportBottomLeft(currXRange, currYRange);
+ }
+
+ if (mZoomer.computeZoom()) {
+ // Performs the zoom since a zoom is in progress (either programmatically or via
+ // double-touch).
+ float newWidth = (1f - mZoomer.getCurrZoom()) * mScrollerStartViewport.width();
+ float newHeight = (1f - mZoomer.getCurrZoom()) * mScrollerStartViewport.height();
+ float pointWithinViewportX = (mZoomFocalPoint.x - mScrollerStartViewport.left)
+ / mScrollerStartViewport.width();
+ float pointWithinViewportY = (mZoomFocalPoint.y - mScrollerStartViewport.top)
+ / mScrollerStartViewport.height();
+ mCurrentViewport.set(
+ mZoomFocalPoint.x - newWidth * pointWithinViewportX,
+ mZoomFocalPoint.y - newHeight * pointWithinViewportY,
+ mZoomFocalPoint.x + newWidth * (1 - pointWithinViewportX),
+ mZoomFocalPoint.y + newHeight * (1 - pointWithinViewportY));
+ constrainViewport();
+ needsInvalidate = true;
+ }
+
+ if (needsInvalidate) {
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+ }
+
+ /**
+ * Sets the current viewport (defined by {@link #mCurrentViewport}) to the given
+ * X and Y positions. Note that the Y value represents the topmost pixel position, and thus
+ * the bottom of the {@link #mCurrentViewport} rectangle. For more details on why top and
+ * bottom are flipped, see {@link #mCurrentViewport}.
+ */
+ private void setViewportBottomLeft(float x, float y) {
+ /**
+ * Constrains within the scroll range. The scroll range is simply the viewport extremes
+ * (AXIS_X_MAX, etc.) minus the viewport size. For example, if the extrema were 0 and 10,
+ * and the viewport size was 2, the scroll range would be 0 to 8.
+ */
+
+ float curWidth = mCurrentViewport.width();
+ float curHeight = mCurrentViewport.height();
+ x = Math.max(AXIS_X_MIN, Math.min(x, AXIS_X_MAX - curWidth));
+ y = Math.max(AXIS_Y_MIN + curHeight, Math.min(y, AXIS_Y_MAX));
+
+ mCurrentViewport.set(x, y - curHeight, x + curWidth, y);
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Methods for programmatically changing the viewport
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Returns the current viewport (visible extremes for the chart domain and range.)
+ */
+ public RectF getCurrentViewport() {
+ return new RectF(mCurrentViewport);
+ }
+
+ /**
+ * Sets the chart's current viewport.
+ *
+ * @see #getCurrentViewport()
+ */
+ public void setCurrentViewport(RectF viewport) {
+ mCurrentViewport = viewport;
+ constrainViewport();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ /**
+ * Smoothly zooms the chart in one step.
+ */
+ public void zoomIn() {
+ mScrollerStartViewport.set(mCurrentViewport);
+ mZoomer.forceFinished(true);
+ mZoomer.startZoom(ZOOM_AMOUNT);
+ mZoomFocalPoint.set(
+ (mCurrentViewport.right + mCurrentViewport.left) / 2,
+ (mCurrentViewport.bottom + mCurrentViewport.top) / 2);
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ /**
+ * Smoothly zooms the chart out one step.
+ */
+ public void zoomOut() {
+ mScrollerStartViewport.set(mCurrentViewport);
+ mZoomer.forceFinished(true);
+ mZoomer.startZoom(-ZOOM_AMOUNT);
+ mZoomFocalPoint.set(
+ (mCurrentViewport.right + mCurrentViewport.left) / 2,
+ (mCurrentViewport.bottom + mCurrentViewport.top) / 2);
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ /**
+ * Smoothly pans the chart left one step.
+ */
+ public void panLeft() {
+ fling((int) (-PAN_VELOCITY_FACTOR * getWidth()), 0);
+ }
+
+ /**
+ * Smoothly pans the chart right one step.
+ */
+ public void panRight() {
+ fling((int) (PAN_VELOCITY_FACTOR * getWidth()), 0);
+ }
+
+ /**
+ * Smoothly pans the chart up one step.
+ */
+ public void panUp() {
+ fling(0, (int) (-PAN_VELOCITY_FACTOR * getHeight()));
+ }
+
+ /**
+ * Smoothly pans the chart down one step.
+ */
+ public void panDown() {
+ fling(0, (int) (PAN_VELOCITY_FACTOR * getHeight()));
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Methods related to custom attributes
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ public float getLabelTextSize() {
+ return mLabelTextSize;
+ }
+
+ public void setLabelTextSize(float labelTextSize) {
+ mLabelTextSize = labelTextSize;
+ initPaints();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ public int getLabelTextColor() {
+ return mLabelTextColor;
+ }
+
+ public void setLabelTextColor(int labelTextColor) {
+ mLabelTextColor = labelTextColor;
+ initPaints();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ public float getGridThickness() {
+ return mGridThickness;
+ }
+
+ public void setGridThickness(float gridThickness) {
+ mGridThickness = gridThickness;
+ initPaints();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ public int getGridColor() {
+ return mGridColor;
+ }
+
+ public void setGridColor(int gridColor) {
+ mGridColor = gridColor;
+ initPaints();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ public float getAxisThickness() {
+ return mAxisThickness;
+ }
+
+ public void setAxisThickness(float axisThickness) {
+ mAxisThickness = axisThickness;
+ initPaints();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ public int getAxisColor() {
+ return mAxisColor;
+ }
+
+ public void setAxisColor(int axisColor) {
+ mAxisColor = axisColor;
+ initPaints();
+ ViewCompat.postInvalidateOnAnimation(this);
+ }
+
+ public float getDataThickness() {
+ return mDataThickness;
+ }
+
+ public void setDataThickness(float dataThickness) {
+ mDataThickness = dataThickness;
+ }
+
+ public int getDataColor() {
+ return mDataColor;
+ }
+
+ public void setDataColor(int dataColor) {
+ mDataColor = dataColor;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Methods and classes related to view state persistence.
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ @Override
+ public Parcelable onSaveInstanceState() {
+ Parcelable superState = super.onSaveInstanceState();
+ SavedState ss = new SavedState(superState);
+ ss.viewport = mCurrentViewport;
+ return ss;
+ }
+
+ @Override
+ public void onRestoreInstanceState(Parcelable state) {
+ if (!(state instanceof SavedState)) {
+ super.onRestoreInstanceState(state);
+ return;
+ }
+
+ SavedState ss = (SavedState) state;
+ super.onRestoreInstanceState(ss.getSuperState());
+
+ mCurrentViewport = ss.viewport;
+ }
+
+ /**
+ * Persistent state that is saved by InteractiveLineGraphView.
+ */
+ public static class SavedState extends BaseSavedState {
+ private RectF viewport;
+
+ public SavedState(Parcelable superState) {
+ super(superState);
+ }
+
+ @Override
+ public void writeToParcel(Parcel out, int flags) {
+ super.writeToParcel(out, flags);
+ out.writeFloat(viewport.left);
+ out.writeFloat(viewport.top);
+ out.writeFloat(viewport.right);
+ out.writeFloat(viewport.bottom);
+ }
+
+ @Override
+ public String toString() {
+ return "InteractiveLineGraphView.SavedState{"
+ + Integer.toHexString(System.identityHashCode(this))
+ + " viewport=" + viewport.toString() + "}";
+ }
+
+ public static final Parcelable.Creator<SavedState> CREATOR
+ = ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() {
+ @Override
+ public SavedState createFromParcel(Parcel in, ClassLoader loader) {
+ return new SavedState(in);
+ }
+
+ @Override
+ public SavedState[] newArray(int size) {
+ return new SavedState[size];
+ }
+ });
+
+ SavedState(Parcel in) {
+ super(in);
+ viewport = new RectF(in.readFloat(), in.readFloat(), in.readFloat(), in.readFloat());
+ }
+ }
+
+ /**
+ * A simple class representing axis label values.
+ *
+ * @see #computeAxisStops
+ */
+ private static class AxisStops {
+ float[] stops = new float[]{};
+ int numStops;
+ int decimals;
+ }
+}
diff --git a/samples/training/InteractiveChart/src/com/example/android/interactivechart/MainActivity.java b/samples/training/InteractiveChart/src/com/example/android/interactivechart/MainActivity.java
new file mode 100755
index 0000000..7c1e56c
--- /dev/null
+++ b/samples/training/InteractiveChart/src/com/example/android/interactivechart/MainActivity.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.interactivechart;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuItem;
+
+public class MainActivity extends Activity {
+ private InteractiveLineGraphView mGraphView;
+
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ mGraphView = (InteractiveLineGraphView) findViewById(R.id.chart);
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ super.onCreateOptionsMenu(menu);
+ getMenuInflater().inflate(R.menu.main, menu);
+ return true;
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case R.id.action_zoom_in:
+ mGraphView.zoomIn();
+ return true;
+
+ case R.id.action_zoom_out:
+ mGraphView.zoomOut();
+ return true;
+
+ case R.id.action_pan_left:
+ mGraphView.panLeft();
+ return true;
+
+ case R.id.action_pan_right:
+ mGraphView.panRight();
+ return true;
+
+ case R.id.action_pan_up:
+ mGraphView.panUp();
+ return true;
+
+ case R.id.action_pan_down:
+ mGraphView.panDown();
+ return true;
+ }
+
+ return super.onOptionsItemSelected(item);
+ }
+}
diff --git a/samples/training/InteractiveChart/src/com/example/android/interactivechart/OverScrollerCompat.java b/samples/training/InteractiveChart/src/com/example/android/interactivechart/OverScrollerCompat.java
new file mode 100644
index 0000000..d33f062
--- /dev/null
+++ b/samples/training/InteractiveChart/src/com/example/android/interactivechart/OverScrollerCompat.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.interactivechart;
+
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.widget.OverScroller;
+
+/**
+ * A utility class for using {@link android.widget.OverScroller} in a backward-compatible fashion.
+ */
+public class OverScrollerCompat {
+ /**
+ * Disallow instantiation.
+ */
+ private OverScrollerCompat() {
+ }
+
+ /**
+ * @see android.view.ScaleGestureDetector#getCurrentSpanY()
+ */
+ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+ public static float getCurrVelocity(OverScroller overScroller) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+ return overScroller.getCurrVelocity();
+ } else {
+ return 0;
+ }
+ }
+}
diff --git a/samples/training/InteractiveChart/src/com/example/android/interactivechart/ScaleGestureDetectorCompat.java b/samples/training/InteractiveChart/src/com/example/android/interactivechart/ScaleGestureDetectorCompat.java
new file mode 100644
index 0000000..fecd9d7
--- /dev/null
+++ b/samples/training/InteractiveChart/src/com/example/android/interactivechart/ScaleGestureDetectorCompat.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.interactivechart;
+
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.view.ScaleGestureDetector;
+
+/**
+ * A utility class for using {@link android.view.ScaleGestureDetector} in a backward-compatible
+ * fashion.
+ */
+public class ScaleGestureDetectorCompat {
+ /**
+ * Disallow instantiation.
+ */
+ private ScaleGestureDetectorCompat() {
+ }
+
+ /**
+ * @see android.view.ScaleGestureDetector#getCurrentSpanX()
+ */
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ public static float getCurrentSpanX(ScaleGestureDetector scaleGestureDetector) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+ return scaleGestureDetector.getCurrentSpanX();
+ } else {
+ return scaleGestureDetector.getCurrentSpan();
+ }
+ }
+
+ /**
+ * @see android.view.ScaleGestureDetector#getCurrentSpanY()
+ */
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ public static float getCurrentSpanY(ScaleGestureDetector scaleGestureDetector) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+ return scaleGestureDetector.getCurrentSpanY();
+ } else {
+ return scaleGestureDetector.getCurrentSpan();
+ }
+ }
+}
diff --git a/samples/training/InteractiveChart/src/com/example/android/interactivechart/Zoomer.java b/samples/training/InteractiveChart/src/com/example/android/interactivechart/Zoomer.java
new file mode 100644
index 0000000..1ae67e4
--- /dev/null
+++ b/samples/training/InteractiveChart/src/com/example/android/interactivechart/Zoomer.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.interactivechart;
+
+import android.content.Context;
+import android.os.SystemClock;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+
+/**
+ * A simple class that animates double-touch zoom gestures. Functionally similar to a {@link
+ * android.widget.Scroller}.
+ */
+public class Zoomer {
+ /**
+ * The interpolator, used for making zooms animate 'naturally.'
+ */
+ private Interpolator mInterpolator;
+
+ /**
+ * The total animation duration for a zoom.
+ */
+ private int mAnimationDurationMillis;
+
+ /**
+ * Whether or not the current zoom has finished.
+ */
+ private boolean mFinished = true;
+
+ /**
+ * The current zoom value; computed by {@link #computeZoom()}.
+ */
+ private float mCurrentZoom;
+
+ /**
+ * The time the zoom started, computed using {@link android.os.SystemClock#elapsedRealtime()}.
+ */
+ private long mStartRTC;
+
+ /**
+ * The destination zoom factor.
+ */
+ private float mEndZoom;
+
+ public Zoomer(Context context) {
+ mInterpolator = new DecelerateInterpolator();
+ mAnimationDurationMillis = context.getResources().getInteger(
+ android.R.integer.config_shortAnimTime);
+ }
+
+ /**
+ * Forces the zoom finished state to the given value. Unlike {@link #abortAnimation()}, the
+ * current zoom value isn't set to the ending value.
+ *
+ * @see android.widget.Scroller#forceFinished(boolean)
+ */
+ public void forceFinished(boolean finished) {
+ mFinished = finished;
+ }
+
+ /**
+ * Aborts the animation, setting the current zoom value to the ending value.
+ *
+ * @see android.widget.Scroller#abortAnimation()
+ */
+ public void abortAnimation() {
+ mFinished = true;
+ mCurrentZoom = mEndZoom;
+ }
+
+ /**
+ * Starts a zoom from 1.0 to (1.0 + endZoom). That is, to zoom from 100% to 125%, endZoom should
+ * by 0.25f.
+ *
+ * @see android.widget.Scroller#startScroll(int, int, int, int)
+ */
+ public void startZoom(float endZoom) {
+ mStartRTC = SystemClock.elapsedRealtime();
+ mEndZoom = endZoom;
+
+ mFinished = false;
+ mCurrentZoom = 1f;
+ }
+
+ /**
+ * Computes the current zoom level, returning true if the zoom is still active and false if the
+ * zoom has finished.
+ *
+ * @see android.widget.Scroller#computeScrollOffset()
+ */
+ public boolean computeZoom() {
+ if (mFinished) {
+ return false;
+ }
+
+ long tRTC = SystemClock.elapsedRealtime() - mStartRTC;
+ if (tRTC >= mAnimationDurationMillis) {
+ mFinished = true;
+ mCurrentZoom = mEndZoom;
+ return false;
+ }
+
+ float t = tRTC * 1f / mAnimationDurationMillis;
+ mCurrentZoom = mEndZoom * mInterpolator.getInterpolation(t);
+ return true;
+ }
+
+ /**
+ * Returns the current zoom level.
+ *
+ * @see android.widget.Scroller#getCurrX()
+ */
+ public float getCurrZoom() {
+ return mCurrentZoom;
+ }
+}
diff --git a/scripts/app_engine_server/memcache_zipserve.py b/scripts/app_engine_server/memcache_zipserve.py
index 68aa0dd..dfd7de9 100644
--- a/scripts/app_engine_server/memcache_zipserve.py
+++ b/scripts/app_engine_server/memcache_zipserve.py
@@ -110,7 +110,7 @@
REDIRECT_TYPE_TEMP = 'temporary' # Redirect 'type'string indicate a 302
# Redirect should be served
intlString = 'intl/'
- validLangs = ['en', 'de', 'es', 'fr','it','ja','ko','ru','zh-CN','zh-TW']
+ validLangs = ['en', 'de', 'es', 'fr','it','ja','ko','ru','zh-CN','zh-cn','zh-TW','zh-tw']
def TrueGet(self, reqUri):
"""The top-level entry point to serving requests.
diff --git a/scripts/app_engine_server/redirects.yaml b/scripts/app_engine_server/redirects.yaml
index b7c28f2..47ee9bb 100644
--- a/scripts/app_engine_server/redirects.yaml
+++ b/scripts/app_engine_server/redirects.yaml
@@ -58,6 +58,14 @@
type: permanent
comment: Redirect sdk reference to new location
+- src: /about/versions/index.html
+ dst: /about/index.html
+ type: permanent
+
+- src: /about/versions/api-levels.html
+ dst: /guide/topics/manifest/uses-sdk-element.html#ApiLevels
+ type: permanent
+
# new one works
- src: /sdk/oem-usb.html
dst: /tools/extras/oem-usb.html
@@ -93,7 +101,10 @@
type: permanent
comment: Redirect sdk reference to new location
-#new one works
+- src: /sdk/ndk/overview.html
+ dst: /tools/sdk/ndk/index.html
+ type: permanent
+
- src: /sdk/ndk/
dst: /tools/sdk/ndk/
type: permanent
@@ -253,7 +264,7 @@
comment: Redirect to new location
# new one
-- src: /guide/basics/what-is-android.html
+- src: /guide/basics/.*
dst: /about/index.html
type: permanent
comment: Redirect to new location
@@ -263,6 +274,11 @@
type: permanent
comment: Redirect to new location
+- src: /guide/topics/security/index.html
+ dst: /training/articles/security-tips.html
+ type: permanent
+ comment: Redirect to new location
+
# new one
- src: /guide/appendix/market-filters.html
dst: /google/play/filters.html
@@ -496,6 +512,9 @@
type: permanent
comment: Syncing with App Engine was removed because it's obsolete.
+- src: /training/basics/location/
+ dst: /training/location/
+ type: permanent
# -------------------- MISC ----------------------
@@ -524,9 +543,13 @@
type: permanent
comment: Redirect to new location
+- src: /intl/zh-CN/...
+ dst: /intl/zh-cn/...
+ type: permanent
-
-
+- src: /intl/zh-TW/...
+ dst: /intl/zh-tw/...
+ type: permanent
# -------------------- EASTER EGG REDIRECTS ----------------------
@@ -583,10 +606,18 @@
dst: http://www.youtube.com/user/androiddevelopers
type: permanent
-- src: /playbadge
+- src: /playbadge/?$
dst: http://developer.android.com/distribute/googleplay/promote/badges.html
type: permanent
-- src: /deviceart
+- src: /deviceart/?$
dst: http://developer.android.com/distribute/promote/device-art.html
type: permanent
+
+- src: /edu/signup/?$
+ dst: https://services.google.com/fb/forms/playedu
+ type: permanent
+
+- src: /edu/?$
+ dst: /distribute/googleplay/edu/index.html
+ type: permanent
diff --git a/sdk/doc_source.prop_template b/sdk/doc_source.prop_template
index d3cdfd5..523d6bd 100644
--- a/sdk/doc_source.prop_template
+++ b/sdk/doc_source.prop_template
@@ -1,4 +1,4 @@
Pkg.UserSrc=false
-Pkg.Revision=1
+Pkg.Revision=2
AndroidVersion.ApiLevel=${PLATFORM_SDK_VERSION}
AndroidVersion.CodeName=${PLATFORM_VERSION_CODENAME}
diff --git a/sdk/platform_source.prop_template b/sdk/platform_source.prop_template
index 88c59ee..73771d9 100644
--- a/sdk/platform_source.prop_template
+++ b/sdk/platform_source.prop_template
@@ -2,7 +2,7 @@
Pkg.UserSrc=false
Platform.Version=${PLATFORM_VERSION}
Platform.CodeName=Jelly Bean
-Pkg.Revision=5
+Pkg.Revision=2
AndroidVersion.ApiLevel=${PLATFORM_SDK_VERSION}
AndroidVersion.CodeName=${PLATFORM_VERSION_CODENAME}
Layoutlib.Api=12
diff --git a/sdk/support_source.properties b/sdk/support_source.properties
index fb611ec..9b4281a 100644
--- a/sdk/support_source.properties
+++ b/sdk/support_source.properties
@@ -1,5 +1,5 @@
Pkg.UserSrc=false
-Pkg.Revision=11
+Pkg.Revision=12
Extra.Vendor=android
Extra.VendorId=android
Extra.VendorDisplay=Android