diff options
Diffstat (limited to 'samples/Support7Demos/src/com/example/android/supportv7/widget')
3 files changed, 458 insertions, 28 deletions
diff --git a/samples/Support7Demos/src/com/example/android/supportv7/widget/AnimatedRecyclerView.java b/samples/Support7Demos/src/com/example/android/supportv7/widget/AnimatedRecyclerView.java index af5c6532d..6714f6d02 100644 --- a/samples/Support7Demos/src/com/example/android/supportv7/widget/AnimatedRecyclerView.java +++ b/samples/Support7Demos/src/com/example/android/supportv7/widget/AnimatedRecyclerView.java @@ -15,13 +15,20 @@ */ package com.example.android.supportv7.widget; -import android.support.v4.util.ArrayMap; -import android.widget.CompoundButton; import com.example.android.supportv7.R; + +import android.animation.Animator; +import android.animation.ValueAnimator; +import android.annotation.TargetApi; import android.app.Activity; import android.content.Context; +import android.os.Build; import android.os.Bundle; +import android.support.v4.util.ArrayMap; import android.support.v4.view.MenuItemCompat; +import android.support.v4.view.ViewCompat; +import android.support.v4.view.ViewPropertyAnimatorListener; +import android.support.v7.widget.DefaultItemAnimator; import android.support.v7.widget.RecyclerView; import android.util.DisplayMetrics; import android.util.TypedValue; @@ -30,10 +37,10 @@ import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; import android.widget.CheckBox; +import android.widget.CompoundButton; import android.widget.TextView; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; public class AnimatedRecyclerView extends Activity { @@ -49,6 +56,7 @@ public class AnimatedRecyclerView extends Activity { boolean mAnimationsEnabled = true; boolean mPredictiveAnimationsEnabled = true; RecyclerView.ItemAnimator mCachedAnimator = null; + boolean mEnableInPlaceChange = true; @Override protected void onCreate(Bundle savedInstanceState) { @@ -57,7 +65,9 @@ public class AnimatedRecyclerView extends Activity { ViewGroup container = (ViewGroup) findViewById(R.id.container); mRecyclerView = new RecyclerView(this); - mCachedAnimator = mRecyclerView.getItemAnimator(); + mCachedAnimator = createAnimator(); + mCachedAnimator.setChangeDuration(2000); + mRecyclerView.setItemAnimator(mCachedAnimator); mRecyclerView.setLayoutManager(new MyLayoutManager(this)); mRecyclerView.setHasFixedSize(true); mRecyclerView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, @@ -91,14 +101,241 @@ public class AnimatedRecyclerView extends Activity { } }); - CheckBox enableChangeAnimations = - (CheckBox) findViewById(R.id.enableChangeAnimations); - enableChangeAnimations.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { + CheckBox enableInPlaceChange = (CheckBox) findViewById(R.id.enableInPlaceChange); + enableInPlaceChange.setChecked(mEnableInPlaceChange); + enableInPlaceChange.setOnCheckedChangeListener( + new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + mEnableInPlaceChange = isChecked; + } + }); + } + + private RecyclerView.ItemAnimator createAnimator() { + return new DefaultItemAnimator() { + List<ItemChangeAnimator> mPendingChangeAnimations = new ArrayList<>(); + ArrayMap<RecyclerView.ViewHolder, ItemChangeAnimator> mRunningAnimations + = new ArrayMap<>(); + ArrayMap<MyViewHolder, Long> mPendingSettleList = new ArrayMap<>(); + @Override - public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { - mCachedAnimator.setSupportsChangeAnimations(isChecked); + public void runPendingAnimations() { + super.runPendingAnimations(); + for (ItemChangeAnimator anim : mPendingChangeAnimations) { + anim.start(); + mRunningAnimations.put(anim.mViewHolder, anim); + } + mPendingChangeAnimations.clear(); + for (int i = mPendingSettleList.size() - 1; i >=0; i--) { + final MyViewHolder vh = mPendingSettleList.keyAt(i); + final long duration = mPendingSettleList.valueAt(i); + ViewCompat.animate(vh.textView).translationX(0f).alpha(1f) + .setDuration(duration).setListener( + new ViewPropertyAnimatorListener() { + @Override + public void onAnimationStart(View view) { + dispatchAnimationStarted(vh); + } + + @Override + public void onAnimationEnd(View view) { + ViewCompat.setTranslationX(vh.textView, 0f); + ViewCompat.setAlpha(vh.textView, 1f); + dispatchAnimationFinished(vh); + } + + @Override + public void onAnimationCancel(View view) { + + } + }).start(); + } + mPendingSettleList.clear(); } - }); + + @Override + public ItemHolderInfo recordPreLayoutInformation(RecyclerView.State state, + RecyclerView.ViewHolder viewHolder, + @AdapterChanges int changeFlags, List<Object> payloads) { + MyItemInfo info = (MyItemInfo) super + .recordPreLayoutInformation(state, viewHolder, changeFlags, payloads); + info.text = ((MyViewHolder) viewHolder).textView.getText(); + return info; + } + + @Override + public ItemHolderInfo recordPostLayoutInformation(RecyclerView.State state, + RecyclerView.ViewHolder viewHolder) { + MyItemInfo info = (MyItemInfo) super.recordPostLayoutInformation(state, viewHolder); + info.text = ((MyViewHolder) viewHolder).textView.getText(); + return info; + } + + + @Override + public boolean canReuseUpdatedViewHolder(RecyclerView.ViewHolder viewHolder) { + return mEnableInPlaceChange; + } + + @Override + public void endAnimation(RecyclerView.ViewHolder item) { + super.endAnimation(item); + for (int i = mPendingChangeAnimations.size() - 1; i >= 0; i--) { + ItemChangeAnimator anim = mPendingChangeAnimations.get(i); + if (anim.mViewHolder == item) { + mPendingChangeAnimations.remove(i); + anim.setFraction(1f); + dispatchChangeFinished(item, true); + } + } + for (int i = mRunningAnimations.size() - 1; i >= 0; i--) { + ItemChangeAnimator animator = mRunningAnimations.get(item); + if (animator != null) { + animator.end(); + mRunningAnimations.removeAt(i); + } + } + for (int i = mPendingSettleList.size() - 1; i >= 0; i--) { + final MyViewHolder vh = mPendingSettleList.keyAt(i); + if (vh == item) { + mPendingSettleList.removeAt(i); + dispatchChangeFinished(item, true); + } + } + } + + @Override + public boolean animateChange(RecyclerView.ViewHolder oldHolder, + RecyclerView.ViewHolder newHolder, ItemHolderInfo preInfo, + ItemHolderInfo postInfo) { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1 + || oldHolder != newHolder) { + return super.animateChange(oldHolder, newHolder, preInfo, postInfo); + } + return animateChangeApiHoneycombMr1(oldHolder, newHolder, preInfo, postInfo); + } + + @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1) + private boolean animateChangeApiHoneycombMr1(RecyclerView.ViewHolder oldHolder, + RecyclerView.ViewHolder newHolder, + ItemHolderInfo preInfo, ItemHolderInfo postInfo) { + endAnimation(oldHolder); + MyItemInfo pre = (MyItemInfo) preInfo; + MyItemInfo post = (MyItemInfo) postInfo; + MyViewHolder vh = (MyViewHolder) oldHolder; + + CharSequence finalText = post.text; + + if (pre.text.equals(post.text)) { + // same content. Just translate back to 0 + final long duration = (long) (getChangeDuration() + * (ViewCompat.getTranslationX(vh.textView) / vh.textView.getWidth())); + mPendingSettleList.put(vh, duration); + // we set it here because previous endAnimation would set it to other value. + vh.textView.setText(finalText); + } else { + // different content, get out and come back. + vh.textView.setText(pre.text); + final ItemChangeAnimator anim = new ItemChangeAnimator(vh, finalText, + getChangeDuration()) { + @Override + public void onAnimationEnd(Animator animation) { + setFraction(1f); + dispatchChangeFinished(mViewHolder, true); + } + + @Override + public void onAnimationStart(Animator animation) { + dispatchChangeStarting(mViewHolder, true); + } + }; + mPendingChangeAnimations.add(anim); + } + return true; + } + + @Override + public ItemHolderInfo obtainHolderInfo() { + return new MyItemInfo(); + } + }; + } + + + @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1) + abstract private static class ItemChangeAnimator implements + ValueAnimator.AnimatorUpdateListener, Animator.AnimatorListener { + CharSequence mFinalText; + ValueAnimator mValueAnimator; + MyViewHolder mViewHolder; + final float mMaxX; + final float mStartRatio; + public ItemChangeAnimator(MyViewHolder viewHolder, CharSequence finalText, long duration) { + mViewHolder = viewHolder; + mMaxX = mViewHolder.itemView.getWidth(); + mStartRatio = ViewCompat.getTranslationX(mViewHolder.textView) / mMaxX; + mFinalText = finalText; + mValueAnimator = ValueAnimator.ofFloat(0f, 1f); + mValueAnimator.addUpdateListener(this); + mValueAnimator.addListener(this); + mValueAnimator.setDuration(duration); + mValueAnimator.setTarget(mViewHolder.itemView); + } + + void setFraction(float fraction) { + fraction = mStartRatio + (1f - mStartRatio) * fraction; + if (fraction < .5f) { + ViewCompat.setTranslationX(mViewHolder.textView, fraction * mMaxX); + ViewCompat.setAlpha(mViewHolder.textView, 1f - fraction); + } else { + ViewCompat.setTranslationX(mViewHolder.textView, (1f - fraction) * mMaxX); + ViewCompat.setAlpha(mViewHolder.textView, fraction); + maybeSetFinalText(); + } + } + + @Override + public void onAnimationUpdate(ValueAnimator valueAnimator) { + setFraction(valueAnimator.getAnimatedFraction()); + } + + public void start() { + mValueAnimator.start(); + } + + @Override + public void onAnimationEnd(Animator animation) { + maybeSetFinalText(); + ViewCompat.setAlpha(mViewHolder.textView, 1f); + } + + public void maybeSetFinalText() { + if (mFinalText != null) { + mViewHolder.textView.setText(mFinalText); + mFinalText = null; + } + } + + public void end() { + mValueAnimator.cancel(); + } + + @Override + public void onAnimationStart(Animator animation) { + } + + @Override + public void onAnimationCancel(Animator animation) { + } + + @Override + public void onAnimationRepeat(Animator animation) { + } + } + + private static class MyItemInfo extends DefaultItemAnimator.ItemHolderInfo { + CharSequence text; } @Override @@ -114,6 +351,7 @@ public class AnimatedRecyclerView extends Activity { return super.onOptionsItemSelected(item); } + @SuppressWarnings("unused") public void checkboxClicked(View view) { ViewGroup parent = (ViewGroup) view.getParent(); boolean selected = ((CheckBox) view).isChecked(); @@ -121,6 +359,7 @@ public class AnimatedRecyclerView extends Activity { mAdapter.selectItem(holder, selected); } + @SuppressWarnings("unused") public void itemClicked(View view) { ViewGroup parent = (ViewGroup) view; MyViewHolder holder = (MyViewHolder) mRecyclerView.getChildViewHolder(parent); @@ -462,20 +701,19 @@ public class AnimatedRecyclerView extends Activity { @Override public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) { String itemText = mData.get(position); - ((MyViewHolder) holder).textView.setText(itemText); - ((MyViewHolder) holder).expandedText.setText("More text for the expanded version"); + MyViewHolder myViewHolder = (MyViewHolder) holder; + myViewHolder.boundText = itemText; + myViewHolder.textView.setText(itemText); boolean selected = false; if (mSelected.get(itemText) != null) { selected = mSelected.get(itemText); } - ((MyViewHolder) holder).checkBox.setChecked(selected); + myViewHolder.checkBox.setChecked(selected); Boolean expanded = mExpanded.get(itemText); - if (expanded != null && expanded) { - ((MyViewHolder) holder).expandedText.setVisibility(View.VISIBLE); - ((MyViewHolder) holder).textView.setVisibility(View.GONE); + if (Boolean.TRUE.equals(expanded)) { + myViewHolder.textView.setText("More text for the expanded version"); } else { - ((MyViewHolder) holder).expandedText.setVisibility(View.GONE); - ((MyViewHolder) holder).textView.setVisibility(View.VISIBLE); + myViewHolder.textView.setText(itemText); } } @@ -484,28 +722,22 @@ public class AnimatedRecyclerView extends Activity { return mData.size(); } - public void selectItem(String itemText, boolean selected) { - mSelected.put(itemText, selected); - } - public void selectItem(MyViewHolder holder, boolean selected) { - mSelected.put((String) holder.textView.getText().toString(), selected); + mSelected.put(holder.boundText, selected); } public void toggleExpanded(MyViewHolder holder) { - String text = (String) holder.textView.getText(); - mExpanded.put(text, !mExpanded.get(text)); + mExpanded.put(holder.boundText, !mExpanded.get(holder.boundText)); } } static class MyViewHolder extends RecyclerView.ViewHolder { - public TextView expandedText; public TextView textView; public CheckBox checkBox; + public String boundText; public MyViewHolder(View v) { super(v); - expandedText = (TextView) v.findViewById(R.id.expandedText); textView = (TextView) v.findViewById(R.id.text); checkBox = (CheckBox) v.findViewById(R.id.selected); } diff --git a/samples/Support7Demos/src/com/example/android/supportv7/widget/BaseLayoutManagerActivity.java b/samples/Support7Demos/src/com/example/android/supportv7/widget/BaseLayoutManagerActivity.java index 782da523b..002a5745f 100644 --- a/samples/Support7Demos/src/com/example/android/supportv7/widget/BaseLayoutManagerActivity.java +++ b/samples/Support7Demos/src/com/example/android/supportv7/widget/BaseLayoutManagerActivity.java @@ -25,6 +25,7 @@ import com.example.android.supportv7.widget.util.ConfigViewHolder; import android.app.Activity; import android.content.Context; import android.os.Bundle; +import android.support.v7.widget.DefaultItemAnimator; import android.support.v7.widget.LinearLayoutManager; import android.support.v7.widget.RecyclerView; import android.view.LayoutInflater; @@ -69,7 +70,7 @@ abstract public class BaseLayoutManagerActivity<T extends RecyclerView.LayoutMan mLayoutManager = createLayoutManager(); mRecyclerView.setLayoutManager(mLayoutManager); mRecyclerView.setAdapter(createAdapter()); - mRecyclerView.getItemAnimator().setSupportsChangeAnimations(true); + ((DefaultItemAnimator)mRecyclerView.getItemAnimator()).setSupportsChangeAnimations(true); onRecyclerViewInit(mRecyclerView); } diff --git a/samples/Support7Demos/src/com/example/android/supportv7/widget/DrawerLayoutActivity.java b/samples/Support7Demos/src/com/example/android/supportv7/widget/DrawerLayoutActivity.java new file mode 100644 index 000000000..8cdf927c2 --- /dev/null +++ b/samples/Support7Demos/src/com/example/android/supportv7/widget/DrawerLayoutActivity.java @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2015 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.supportv7.widget; + +import android.content.res.Configuration; +import android.os.Bundle; +import android.support.v4.view.GravityCompat; +import android.support.v4.widget.DrawerLayout; +import android.support.v7.app.ActionBarDrawerToggle; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.Toolbar; +import android.view.MenuItem; +import android.view.View; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.ListView; +import android.widget.TextView; +import com.example.android.supportv7.R; +import com.example.android.supportv7.Shakespeare; + +/** + * This example illustrates a common usage of the DrawerLayout widget combined with Toolbar + * in the Android support library that respect the + * <a href="https://www.google.com/design/spec/patterns/navigation-drawer.html">Material design + * guidelines</a> for the drawer component. + * + * + * <p>A DrawerLayout should be positioned at the top of your view hierarchy, placing it + * below the action bar but above your content views. The primary content should match_parent + * in both dimensions. Each drawer should define a reasonable width and match_parent for height. + * Drawer views should be positioned after the content view in your layout to preserve proper + * ordering.</p> + * + * <p>When a navigation (left) drawer is present, the host activity should detect presses of + * the action bar's Up affordance as a signal to open and close the navigation drawer. + * Items within the drawer should fall into one of two categories.</p> + * + * <ul> + * <li><strong>View switches</strong>. A view switch follows the same basic policies as + * list or tab navigation in that a view switch does not create navigation history. + * This pattern should only be used at the root activity of a task, leaving some form + * of Up navigation active for activities further down the navigation hierarchy.</li> + * <li><strong>Selective Up</strong>. The drawer allows the user to choose an alternate + * parent for Up navigation. This allows a user to jump across an app's navigation + * hierarchy at will. The application should treat this as it treats Up navigation from + * a different task, replacing the current task stack using TaskStackBuilder or similar. + * This is the only form of navigation drawer that should be used outside of the root + * activity of a task.</li> + * </ul> + * + * <p>Right side drawers should be used for actions, not navigation. This follows the pattern + * established by the Action Bar that navigation should be to the left and actions to the right. + * An action should be an operation performed on the current contents of the window, + * for example enabling or disabling a data overlay on top of the current content.</p> + * + * <p>When the drawer is open, it is above the application toolbar. On Lollipop versions of the + * platform and above the drawer spans the full height of the screen, including behind the system + * status bar.</p> + */ +public class DrawerLayoutActivity extends AppCompatActivity { + private DrawerLayout mDrawerLayout; + private ListView mDrawer; + private TextView mContent; + + private ActionBarDrawerToggle mDrawerToggle; + private Toolbar mToolbar; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + setContentView(R.layout.drawer_layout); + + mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout); + mDrawer = (ListView) findViewById(R.id.start_drawer); + mContent = (TextView) findViewById(R.id.content_text); + + mDrawerLayout.setDrawerShadow(R.drawable.drawer_shadow, GravityCompat.START); + + // The drawer title must be set in order to announce state changes when + // accessibility is turned on. This is typically a simple description, + // e.g. "Navigation". + mDrawerLayout.setDrawerTitle(GravityCompat.START, getString(R.string.drawer_title)); + + mDrawer.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, + Shakespeare.TITLES)); + mDrawer.setOnItemClickListener(new DrawerItemClickListener()); + + // Find the toolbar in our layout and set it as the support action bar on the activity. + // This is required to have the drawer slide "over" the toolbar. + mToolbar = (Toolbar) findViewById(R.id.toolbar); + mToolbar.setTitle(R.string.drawer_title); + setSupportActionBar(mToolbar); + + getSupportActionBar().setDisplayHomeAsUpEnabled(true); + getSupportActionBar().setDisplayShowHomeEnabled(false); + + // ActionBarDrawerToggle provides convenient helpers for tying together the + // prescribed interactions between a top-level sliding drawer and the action bar. + // Note that, as the Javadocs of ActionBarDrawerToggle constructors say, we are + // *not* using a constructor that gets a Toolbar since we're setting our toolbar + // dynamically at runtime. Furthermore, as the drawer is sliding over the toolbar, + // we are suppressing the morphing animation from hamburger to back arrow by + // calling super.onDrawerSlide with slideOffset=0.0f. In case your app only has + // top-level pages and doesn't need back arrow visuals at all, you can set up + // your activity theme to have attribute named "drawerArrowStyle" that points + // to an extension of Widget.AppCompat.DrawerArrowToggle that has its "spinBars" + // attribute set to false. + mDrawerToggle = new ActionBarDrawerToggle(this, mDrawerLayout, + R.string.drawer_open, R.string.drawer_close) { + @Override + public void onDrawerOpened(View drawerView) { + super.onDrawerOpened(drawerView); + super.onDrawerSlide(drawerView, 0.0f); + } + + @Override + public void onDrawerSlide(View drawerView, float slideOffset) { + super.onDrawerSlide(drawerView, 0.0f); + } + }; + + mDrawerLayout.setDrawerListener(mDrawerToggle); + + // Configure the background color fill of the system status bar (on supported platform + // versions) and the toolbar itself. We're using the same color, and android:statusBar + // from the theme makes the status bar slightly darker. + final int metalBlueColor = getResources().getColor(R.color.drawer_sample_metal_blue); + mDrawerLayout.setStatusBarBackgroundColor(metalBlueColor); + mToolbar.setBackgroundColor(metalBlueColor); + } + + @Override + protected void onPostCreate(Bundle savedInstanceState) { + super.onPostCreate(savedInstanceState); + + // Sync the toggle state after onRestoreInstanceState has occurred. + mDrawerToggle.syncState(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + /* + * The action bar home/up action should open or close the drawer. + * The drawer toggle will take care of this. + */ + if (mDrawerToggle.onOptionsItemSelected(item)) { + return true; + } + return super.onOptionsItemSelected(item); + } + + @Override + public void onBackPressed() { + // Is the drawer open? + if (mDrawerLayout.isDrawerOpen(mDrawer)) { + // Close the drawer and return. + mDrawerLayout.closeDrawer(mDrawer); + return; + } + + super.onBackPressed(); + } + + @Override + public void onConfigurationChanged(Configuration newConfig) { + super.onConfigurationChanged(newConfig); + mDrawerToggle.onConfigurationChanged(newConfig); + } + + /** + * This list item click listener implements very simple view switching by changing + * the primary content text. The drawer is closed when a selection is made. + */ + private class DrawerItemClickListener implements ListView.OnItemClickListener { + @Override + public void onItemClick(AdapterView<?> parent, View view, int position, long id) { + mContent.setText(Shakespeare.DIALOGUE[position]); + mToolbar.setTitle(Shakespeare.TITLES[position]); + mDrawerLayout.closeDrawer(mDrawer); + } + } +} |