281 lines
10 KiB
Java
281 lines
10 KiB
Java
/*
|
|
* Copyright 2014 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.adaptertransition;
|
|
|
|
import android.os.Bundle;
|
|
import android.support.v4.app.ActivityCompat;
|
|
import android.support.v4.app.Fragment;
|
|
import android.transition.AutoTransition;
|
|
import android.transition.Scene;
|
|
import android.transition.Transition;
|
|
import android.transition.TransitionManager;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.AbsListView;
|
|
import android.widget.FrameLayout;
|
|
import android.widget.GridView;
|
|
import android.widget.ListView;
|
|
import android.widget.Toast;
|
|
|
|
/**
|
|
* Main screen for AdapterTransition sample.
|
|
*/
|
|
public class AdapterTransitionFragment extends Fragment implements Transition.TransitionListener {
|
|
|
|
/**
|
|
* Since the transition framework requires all relevant views in a view hierarchy to be marked
|
|
* with IDs, we use this ID to mark the root view.
|
|
*/
|
|
private static final int ROOT_ID = 1;
|
|
|
|
/**
|
|
* A tag for saving state whether the mAbsListView is ListView or GridView.
|
|
*/
|
|
private static final String STATE_IS_LISTVIEW = "is_listview";
|
|
|
|
/**
|
|
* This is where we place our AdapterView (ListView / GridView).
|
|
*/
|
|
private FrameLayout mContent;
|
|
|
|
/**
|
|
* This is where we carry out the transition.
|
|
*/
|
|
private FrameLayout mCover;
|
|
|
|
/**
|
|
* This list shows our contents. It can be ListView or GridView, and we toggle between them
|
|
* using the transition framework.
|
|
*/
|
|
private AbsListView mAbsListView;
|
|
|
|
/**
|
|
* This is our contents.
|
|
*/
|
|
private MeatAdapter mAdapter;
|
|
|
|
public static AdapterTransitionFragment newInstance() {
|
|
return new AdapterTransitionFragment();
|
|
}
|
|
|
|
public AdapterTransitionFragment() {
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
setHasOptionsMenu(true);
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container,
|
|
Bundle savedInstanceState) {
|
|
// If savedInstanceState is available, we restore the state whether the list is a ListView
|
|
// or a GridView.
|
|
boolean isListView;
|
|
if (null == savedInstanceState) {
|
|
isListView = true;
|
|
} else {
|
|
isListView = savedInstanceState.getBoolean(STATE_IS_LISTVIEW, true);
|
|
}
|
|
inflateAbsList(inflater, container, isListView);
|
|
return inflater.inflate(R.layout.fragment_adapter_transition, container, false);
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
outState.putBoolean(STATE_IS_LISTVIEW, mAbsListView instanceof ListView);
|
|
}
|
|
|
|
@Override
|
|
public void onViewCreated(View view, Bundle savedInstanceState) {
|
|
// Retaining references for FrameLayouts that we use later.
|
|
mContent = (FrameLayout) view.findViewById(R.id.content);
|
|
mCover = (FrameLayout) view.findViewById(R.id.cover);
|
|
// We are attaching the list to the screen here.
|
|
mContent.addView(mAbsListView);
|
|
}
|
|
|
|
@Override
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
|
|
inflater.inflate(R.menu.fragment_adapter_transition, menu);
|
|
}
|
|
|
|
@Override
|
|
public void onPrepareOptionsMenu(Menu menu) {
|
|
// We change the look of the icon every time the user toggles between list and grid.
|
|
MenuItem item = menu.findItem(R.id.action_toggle);
|
|
if (null != item) {
|
|
if (mAbsListView instanceof ListView) {
|
|
item.setIcon(R.drawable.ic_action_grid);
|
|
item.setTitle(R.string.show_as_grid);
|
|
} else {
|
|
item.setIcon(R.drawable.ic_action_list);
|
|
item.setTitle(R.string.show_as_list);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
case R.id.action_toggle: {
|
|
toggle();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onTransitionStart(Transition transition) {
|
|
}
|
|
|
|
// BEGIN_INCLUDE(on_transition_end)
|
|
@Override
|
|
public void onTransitionEnd(Transition transition) {
|
|
// When the transition ends, we remove all the views from the overlay and hide it.
|
|
mCover.removeAllViews();
|
|
mCover.setVisibility(View.INVISIBLE);
|
|
}
|
|
// END_INCLUDE(on_transition_end)
|
|
|
|
@Override
|
|
public void onTransitionCancel(Transition transition) {
|
|
}
|
|
|
|
@Override
|
|
public void onTransitionPause(Transition transition) {
|
|
}
|
|
|
|
@Override
|
|
public void onTransitionResume(Transition transition) {
|
|
}
|
|
|
|
/**
|
|
* Inflate a ListView or a GridView with a corresponding ListAdapter.
|
|
*
|
|
* @param inflater The LayoutInflater.
|
|
* @param container The ViewGroup that contains this AbsListView. The AbsListView won't be
|
|
* attached to it.
|
|
* @param inflateListView Pass true to inflate a ListView, or false to inflate a GridView.
|
|
*/
|
|
private void inflateAbsList(LayoutInflater inflater, ViewGroup container,
|
|
boolean inflateListView) {
|
|
if (inflateListView) {
|
|
mAbsListView = (AbsListView) inflater.inflate(R.layout.fragment_meat_list,
|
|
container, false);
|
|
mAdapter = new MeatAdapter(inflater, R.layout.item_meat_list);
|
|
} else {
|
|
mAbsListView = (AbsListView) inflater.inflate(R.layout.fragment_meat_grid,
|
|
container, false);
|
|
mAdapter = new MeatAdapter(inflater, R.layout.item_meat_grid);
|
|
}
|
|
mAbsListView.setAdapter(mAdapter);
|
|
mAbsListView.setOnItemClickListener(mAdapter);
|
|
}
|
|
|
|
/**
|
|
* Toggle the UI between ListView and GridView.
|
|
*/
|
|
private void toggle() {
|
|
// We use mCover as the overlay on which we carry out the transition.
|
|
mCover.setVisibility(View.VISIBLE);
|
|
// This FrameLayout holds all the visible views in the current list or grid. We use this as
|
|
// the starting Scene of the Transition later.
|
|
FrameLayout before = copyVisibleViews();
|
|
FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
|
|
FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
|
|
mCover.addView(before, params);
|
|
// Swap the actual list.
|
|
swapAbsListView();
|
|
// We also swap the icon for the toggle button.
|
|
ActivityCompat.invalidateOptionsMenu(getActivity());
|
|
// It is now ready to start the transition.
|
|
mAbsListView.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
// BEGIN_INCLUDE(transition_with_listener)
|
|
Scene scene = new Scene(mCover, copyVisibleViews());
|
|
Transition transition = new AutoTransition();
|
|
transition.addListener(AdapterTransitionFragment.this);
|
|
TransitionManager.go(scene, transition);
|
|
// END_INCLUDE(transition_with_listener)
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Swap ListView with GridView, or GridView with ListView.
|
|
*/
|
|
private void swapAbsListView() {
|
|
// We save the current scrolling position before removing the current list.
|
|
int first = mAbsListView.getFirstVisiblePosition();
|
|
// If the current list is a GridView, we replace it with a ListView. If it is a ListView,
|
|
// a GridView.
|
|
LayoutInflater inflater = LayoutInflater.from(getActivity());
|
|
inflateAbsList(inflater, (ViewGroup) mAbsListView.getParent(),
|
|
mAbsListView instanceof GridView);
|
|
mAbsListView.setAdapter(mAdapter);
|
|
// We restore the scrolling position here.
|
|
mAbsListView.setSelection(first);
|
|
// The new list is ready, and we replace the existing one with it.
|
|
mContent.removeAllViews();
|
|
mContent.addView(mAbsListView);
|
|
}
|
|
|
|
/**
|
|
* Copy all the visible views in the mAbsListView into a new FrameLayout and return it.
|
|
*
|
|
* @return a FrameLayout with all the visible views inside.
|
|
*/
|
|
private FrameLayout copyVisibleViews() {
|
|
// This is the FrameLayout we return afterwards.
|
|
FrameLayout layout = new FrameLayout(getActivity());
|
|
// The transition framework requires to set ID for all views to be animated.
|
|
layout.setId(ROOT_ID);
|
|
// We only copy visible views.
|
|
int first = mAbsListView.getFirstVisiblePosition();
|
|
int index = 0;
|
|
while (true) {
|
|
// This is one of the views that we copy. Note that the argument for getChildAt is a
|
|
// zero-oriented index, and it doesn't usually match with its position in the list.
|
|
View source = mAbsListView.getChildAt(index);
|
|
if (null == source) {
|
|
break;
|
|
}
|
|
// This is the copy of the original view.
|
|
View destination = mAdapter.getView(first + index, null, layout);
|
|
assert destination != null;
|
|
destination.setId(ROOT_ID + first + index);
|
|
FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
|
|
source.getWidth(), source.getHeight());
|
|
params.leftMargin = (int) source.getX();
|
|
params.topMargin = (int) source.getY();
|
|
layout.addView(destination, params);
|
|
++index;
|
|
}
|
|
return layout;
|
|
}
|
|
|
|
}
|