diff options
Diffstat (limited to 'tests/TransitionTests/src/com/android')
28 files changed, 2330 insertions, 0 deletions
diff --git a/tests/TransitionTests/src/com/android/transitiontests/ChangingText.java b/tests/TransitionTests/src/com/android/transitiontests/ChangingText.java new file mode 100644 index 0000000..ed9b46a --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ChangingText.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.widget.Button; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.TextChange; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + +public class ChangingText extends Activity { + + Button mRemovingButton, mInvisibleButton, mGoneButton; + Scene mScene1, mScene2; + ViewGroup mSceneRoot; + Fade fader; + TransitionGroup mChanger; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.changing_text_1); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mScene1 = new Scene(mSceneRoot, R.layout.changing_text_1, this); + mScene2 = new Scene(mSceneRoot, R.layout.changing_text_2, this); + + mChanger = new TransitionGroup(TransitionGroup.TOGETHER); + mChanger.addTransitions(new Move(), new TextChange()); + + mSceneRoot.setCurrentScene(mScene1); + } + + public void sendMessage(View view) { + if (mSceneRoot.getCurrentScene() == mScene1) { + TransitionManager.go(mScene2, mChanger); + } else { + TransitionManager.go(mScene1, mChanger); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ClippingText.java b/tests/TransitionTests/src/com/android/transitiontests/ClippingText.java new file mode 100644 index 0000000..0ecf1f4 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ClippingText.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.widget.Button; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.TextChange; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + +public class ClippingText extends Activity { + + Button mRemovingButton, mInvisibleButton, mGoneButton; + Scene mScene1, mScene2; + ViewGroup mSceneRoot; + // static Fade sFade = new Fade(R.id.removingButton, R.id.invisibleButton, R.id.goneButton); + Fade fader; + TransitionGroup mChanger; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.clipping_text_1); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mScene1 = new Scene(mSceneRoot, R.layout.clipping_text_1, this); + mScene2 = new Scene(mSceneRoot, R.layout.clipping_text_2, this); + + mChanger = new TransitionGroup(TransitionGroup.TOGETHER); + Move move = new Move(); + move.setResizeClip(true); + mChanger.addTransitions(move, new TextChange()); + + mSceneRoot.setCurrentScene(mScene1); + } + + public void sendMessage(View view) { + if (mSceneRoot.getCurrentScene() == mScene1) { + TransitionManager.go(mScene2, mChanger); + } else { + TransitionManager.go(mScene1, mChanger); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ContactsExpansion.java b/tests/TransitionTests/src/com/android/transitiontests/ContactsExpansion.java new file mode 100644 index 0000000..55a96a5 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ContactsExpansion.java @@ -0,0 +1,123 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Scene; +import android.view.transition.Transition; +import android.widget.ImageView; +import android.widget.TextView; +import android.view.transition.Crossfade; +import android.view.transition.Move; +import android.view.transition.Rotate; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + +public class ContactsExpansion extends Activity { + + String contactsData[] = { + "Alan Green", "56 Bob Street", "Boston, MA 02134", "617-555-5555", "blatt@blatt.com", + "Bob Foonman", "92 The Avenue", "Chico, CA 78456", "510-555-5556", "bob@jerk.com", + "Tracey Sue", "95 Houses Street", "San Jose, CA 96504", "415-555-5557", "ts@thing.com", + }; + + View currentItem = null; + + TransitionGroup mMyAutoTransition = new TransitionGroup(TransitionGroup.SEQUENTIALLY); + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.contacts_list); + ViewGroup contactsContainer = (ViewGroup) findViewById(R.id.contactsContainer); + + int contactsIndex = 0; + addContact(contactsContainer, contactsIndex, R.drawable.self_portrait_square_100); + contactsIndex += 5; + addContact(contactsContainer, contactsIndex, R.drawable.self_portrait_square_100); + contactsIndex += 5; + addContact(contactsContainer, contactsIndex, R.drawable.self_portrait_square_100); + + } + + private void addContact(ViewGroup container, int dataIndex, int thumbnailID) { + LayoutInflater inflater = (LayoutInflater) + getSystemService(Context.LAYOUT_INFLATER_SERVICE); + View contactItem = inflater.inflate(R.layout.contact_collapsed, container, false); + ImageView thumbnailView = (ImageView) contactItem.findViewById(R.id.contact_picture); + thumbnailView.setImageResource(thumbnailID); + ((TextView)contactItem.findViewById(R.id.contact_name)).setText(contactsData[dataIndex++]); + ((TextView)contactItem.findViewById(R.id.contact_street)). + setText(contactsData[dataIndex++]); + ((TextView)contactItem.findViewById(R.id.contact_city)).setText(contactsData[dataIndex++]); + ((TextView)contactItem.findViewById(R.id.contact_phone)).setText(contactsData[dataIndex++]); + ((TextView)contactItem.findViewById(R.id.contact_email)).setText(contactsData[dataIndex++]); + container.addView(contactItem); + + final TransitionGroup myTransition = new TransitionGroup(); + myTransition.addTransitions(new Fade(Fade.IN), + new Rotate().setTargetIds(R.id.contact_arrow), + new Move(), new Fade(Fade.OUT), + new Crossfade().setTargetIds(R.id.contact_picture)); + final ToggleScene toggleScene = new ToggleScene(container, myTransition); + contactItem.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + currentItem = v; + toggleScene.changeToScene(); + } + }); + } + + class ToggleScene { + boolean expanded = false; + Scene mScene; + Transition mTransition; + + ToggleScene(ViewGroup rootView, Transition transition) { + mScene = new Scene(rootView); + mTransition = transition; + mScene.setEnterAction(new Runnable() { + @Override + public void run() { + if (currentItem != null) { + System.out.println("onsceneChanged: currentItem = " + currentItem); + View expandedContainer = currentItem.findViewById(R.id.expanded_info); + expandedContainer.setVisibility(expanded ? View.GONE : View.VISIBLE); + ImageView thumbnailView = + (ImageView) currentItem.findViewById(R.id.contact_picture); + thumbnailView.setImageResource(expanded ? R.drawable.self_portrait_square_100 : + R.drawable.self_portrait_square_200); + ImageView arrow = (ImageView) currentItem.findViewById(R.id.contact_arrow); + arrow.setRotation(expanded ? 0 : 90); + expanded = !expanded; + } + } + }); + } + + void changeToScene() { + TransitionManager.go(mScene, mTransition); + } + }; +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/CrossFadeDemo.java b/tests/TransitionTests/src/com/android/transitiontests/CrossFadeDemo.java new file mode 100644 index 0000000..c428a73 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/CrossFadeDemo.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Crossfade; +import android.view.transition.Move; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class CrossFadeDemo extends Activity { + + ViewGroup mSceneRoot; + static int mCurrentScene; + Scene mScene1, mScene2; + TransitionManager mTransitionManager; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.crossfade); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mScene1 = new Scene(mSceneRoot, R.layout.crossfade, this); + mScene2 = new Scene(mSceneRoot, R.layout.crossfade_1, this); + + Crossfade crossfade = new Crossfade(); + crossfade.setTargetIds(R.id.textview, R.id.textview1, R.id.textview2); + mTransitionManager = new TransitionManager(); + TransitionGroup moveCrossFade = new TransitionGroup(); + moveCrossFade.addTransitions(crossfade, new Move()); + mTransitionManager.setTransition(mScene1, moveCrossFade); + mTransitionManager.setTransition(mScene2, moveCrossFade); + mCurrentScene = 1; + } + + public void sendMessage(View view) { + if (mCurrentScene == 1) { + mTransitionManager.transitionTo(mScene2); + mCurrentScene = 2; + } else { + mTransitionManager.transitionTo(mScene1); + mCurrentScene = 1; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Demo0.java b/tests/TransitionTests/src/com/android/transitiontests/Demo0.java new file mode 100644 index 0000000..55bf956 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Demo0.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import com.android.transitiontest.R; + + +public class Demo0 extends Activity { + + private static final int SEARCH_SCREEN = 0; + private static final int RESULTS_SCREEN = 1; + ViewGroup mSceneRoot; + static int mCurrentScene; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mCurrentScene = SEARCH_SCREEN; + } + + public void sendMessage(View view) { + if (mCurrentScene == RESULTS_SCREEN) { + mSceneRoot.removeAllViews(); + LayoutInflater inflater = (LayoutInflater) + getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.search_screen, mSceneRoot); + mCurrentScene = SEARCH_SCREEN; + } else { + mSceneRoot.removeAllViews(); + LayoutInflater inflater = (LayoutInflater) + getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.results_screen, mSceneRoot); + mCurrentScene = RESULTS_SCREEN; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Demo1.java b/tests/TransitionTests/src/com/android/transitiontests/Demo1.java new file mode 100644 index 0000000..360a764 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Demo1.java @@ -0,0 +1,88 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class Demo1 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + boolean mFirstTime = true; + Scene mSearchScreen, mResultsScreen; + TransitionManager mTransitionManager = null; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + +// mResultsScreen = new MyScene(mSceneRoot, R.layout.results_screen); +// mSearchScreen = new MyScene(mSceneRoot, R.layout.search_screen); + mResultsScreen = new Scene(mSceneRoot); + mResultsScreen.setEnterAction(new Runnable() { + @Override + public void run() { + LayoutInflater inflater = (LayoutInflater) + getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.results_screen, mSceneRoot); + } + }); + mSearchScreen = new Scene(mSceneRoot); + mSearchScreen.setEnterAction(new Runnable() { + @Override + public void run() { + LayoutInflater inflater = (LayoutInflater) + getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.search_screen, mSceneRoot); + } + }); + + } + + public void sendMessage(View view) { + if (mFirstTime) { + mFirstTime = false; + TransitionGroup transition = new TransitionGroup(); + transition.addTransitions(new Fade().setTargetIds(R.id.resultsText, R.id.resultsList), + new Move().setTargetIds(R.id.searchContainer)); + mTransitionManager = new TransitionManager(); + mTransitionManager.setTransition(mSearchScreen, transition); + mTransitionManager.setTransition(mResultsScreen, transition); + } + if (mCurrentScene == mResultsScreen) { + mTransitionManager.transitionTo(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + mTransitionManager.transitionTo(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Demo2.java b/tests/TransitionTests/src/com/android/transitiontests/Demo2.java new file mode 100644 index 0000000..40f8a08 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Demo2.java @@ -0,0 +1,79 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Recolor; +import android.view.transition.Scene; +import android.view.transition.TransitionInflater; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + +public class Demo2 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + boolean mFirstTime = true; + Scene mSearchScreen, mResultsScreen; + TransitionManager mTransitionManager = null; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + } + + public void sendMessage(View view) { + if (mFirstTime) { + mFirstTime = false; + // Non-resource approach of creating scenes +// mSearchScreen = new Scene(this, mSceneRoot, R.layout.search_screen); +// mResultsScreen = new Scene(this, mSceneRoot, R.layout.results_screen); + try { + mSearchScreen = TransitionInflater.from(this). + inflateScene(R.scene.search_scene, mSceneRoot); + mResultsScreen = TransitionInflater.from(this). + inflateScene(R.scene.results_scene, mSceneRoot); + } catch (Exception e) { + System.out.println("Problem loading scene resource: " + e); + } + + TransitionGroup transition = new TransitionGroup(); + transition.addTransitions(new Fade().setTargetIds(R.id.resultsText, R.id.resultsList), + new Move().setTargetIds(R.id.searchContainer), + new Recolor().setTargetIds(R.id.container)); + mTransitionManager = new TransitionManager(); + mTransitionManager.setTransition(mSearchScreen, transition); + mTransitionManager.setTransition(mResultsScreen, transition); + } + if (mCurrentScene == mResultsScreen) { + mTransitionManager.transitionTo(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + mTransitionManager.transitionTo(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Demo3.java b/tests/TransitionTests/src/com/android/transitiontests/Demo3.java new file mode 100644 index 0000000..f30f502 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Demo3.java @@ -0,0 +1,65 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Recolor; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class Demo3 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + Scene mSearchScreen, mResultsScreen; + TransitionManager mTransitionManager = null; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + + TransitionGroup transition = new TransitionGroup(); + transition.addTransitions(new Fade(), new Move(), new Recolor()); + + mTransitionManager = new TransitionManager(); + mTransitionManager.setTransition(mSearchScreen, transition); + mTransitionManager.setTransition(mResultsScreen, transition); + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + mTransitionManager.transitionTo(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + mTransitionManager.transitionTo(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Demo4.java b/tests/TransitionTests/src/com/android/transitiontests/Demo4.java new file mode 100644 index 0000000..41d6d08 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Demo4.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Recolor; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class Demo4 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + Scene mSearchScreen, mResultsScreen; + TransitionManager mTransitionManager = null; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + + TransitionGroup transitionToResults = new TransitionGroup(); + Fade fade = new Fade(); + fade.setTargetIds(R.id.resultsText, R.id.resultsList); + fade.setStartDelay(300); + fade.setDuration(1000); + transitionToResults.addTransitions(fade, new Move().setTargetIds(R.id.searchContainer), + new Recolor().setTargetIds(R.id.container)); + + TransitionGroup transitionToSearch = new TransitionGroup(); + transitionToSearch.addTransitions(fade, new Move().setTargetIds(R.id.searchContainer), + new Recolor().setTargetIds(R.id.container)); + + mTransitionManager = new TransitionManager(); + mTransitionManager.setTransition(mSearchScreen, transitionToSearch); + mTransitionManager.setTransition(mResultsScreen, transitionToResults); + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + mTransitionManager.transitionTo(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + mTransitionManager.transitionTo(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Demo5.java b/tests/TransitionTests/src/com/android/transitiontests/Demo5.java new file mode 100644 index 0000000..9d64f07 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Demo5.java @@ -0,0 +1,54 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class Demo5 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + Scene mSearchScreen, mResultsScreen; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + TransitionManager.go(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + TransitionManager.go(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/FadingTest.java b/tests/TransitionTests/src/com/android/transitiontests/FadingTest.java new file mode 100644 index 0000000..7d30dfd --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/FadingTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.widget.Button; +import android.view.transition.Fade; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class FadingTest extends Activity { + + Button mRemovingButton, mInvisibleButton, mGoneButton; + Scene mScene1, mScene2; + ViewGroup mSceneRoot; + static Fade sFade = new Fade(); + + static { + sFade.setTargetIds(R.id.removingButton, R.id.invisibleButton, R.id.goneButton); + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.fading_test); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + + mRemovingButton = (Button) findViewById(R.id.removingButton); + mInvisibleButton = (Button) findViewById(R.id.invisibleButton); + mGoneButton = (Button) findViewById(R.id.goneButton); + + mGoneButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mGoneButton.setAlpha(mGoneButton.getAlpha() < 1 ? 1 : .6f); + } + }); + + mScene1 = new Scene(mSceneRoot, R.layout.fading_test, this); + mScene2 = new Scene(mSceneRoot, R.layout.fading_test_scene_2, this); + + mSceneRoot.setCurrentScene(mScene1); + } + + public void sendMessage(View view) { + if (mSceneRoot.getCurrentScene() == mScene1) { + TransitionManager.go(mScene2); + } else { + TransitionManager.go(mScene1); + } + } + +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/HitRectBug.java b/tests/TransitionTests/src/com/android/transitiontests/HitRectBug.java new file mode 100644 index 0000000..33e00a8 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/HitRectBug.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.animation.ObjectAnimator; +import android.animation.ValueAnimator; +import android.app.Activity; +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.graphics.Rect; +import android.os.Bundle; +import android.view.View; +import android.widget.ImageView; +import android.widget.RelativeLayout; +import com.android.transitiontest.R; + + +public class HitRectBug extends Activity { + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(new TestDrawingView(this)); + } + + public static class TestDrawingView extends RelativeLayout + { + private Rect mRect = new Rect(); + private Paint mPaint; + private ImageView mImageView; + + public TestDrawingView(Context context) + { + super(context); + setWillNotDraw(false); + + mPaint = new Paint(); + mPaint.setColor(Color.RED); + mPaint.setStyle(Paint.Style.STROKE); + + mImageView = new ImageView(context); + mImageView.setLeft(100); + mImageView.setRight(200); + mImageView.setImageResource(R.drawable.self_portrait_square); + mImageView.setScaleX(3); + mImageView.setScaleY(3); +// mImageView.setRotation(145); + + ObjectAnimator anim = ObjectAnimator.ofFloat(mImageView, View.ROTATION, 0, 360); + anim.setRepeatCount(ValueAnimator.INFINITE); + anim.setDuration(5000); + anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + invalidate(); + } + }); + anim.start(); + RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(128, 128); + params.addRule(RelativeLayout.CENTER_IN_PARENT); + addView(mImageView, params); + } + + @Override + protected void onDraw(Canvas canvas) + { + super.onDraw(canvas); + } + + @Override + protected void dispatchDraw(Canvas canvas) { + super.dispatchDraw(canvas); + mImageView.getHitRect(mRect); + canvas.drawRect(mRect, mPaint); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/InstanceTargets.java b/tests/TransitionTests/src/com/android/transitiontests/InstanceTargets.java new file mode 100644 index 0000000..efccfa9 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/InstanceTargets.java @@ -0,0 +1,69 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Move; +import android.view.transition.Scene; +import android.view.transition.TransitionManager; +import android.widget.Button; +import android.widget.RelativeLayout; +import com.android.transitiontest.R; + +import static android.widget.RelativeLayout.ALIGN_PARENT_LEFT; +import static android.widget.RelativeLayout.ALIGN_PARENT_RIGHT; +import static android.widget.RelativeLayout.LayoutParams; + +public class InstanceTargets extends Activity { + + ViewGroup mSceneRoot; + static int mCurrentScene; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.instance_targets); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container; + } + + public void sendMessage(final View view) { + TransitionManager.go(mSceneRoot, new Runnable() { + @Override + public void run() { + for (int i = 0; i < mSceneRoot.getChildCount(); ++i) { + Button button = (Button) mSceneRoot.getChildAt(i); + LayoutParams params = (LayoutParams) button.getLayoutParams(); + int rules[] = params.getRules(); + if (rules[ALIGN_PARENT_RIGHT] != 0) { + params.removeRule(ALIGN_PARENT_RIGHT); + params.addRule(ALIGN_PARENT_LEFT); + } else { + params.removeRule(ALIGN_PARENT_LEFT); + params.addRule(ALIGN_PARENT_RIGHT); + } + button.setLayoutParams(params); + } + } + }, new Move().setTargets(view)); + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ListViewAddRemove.java b/tests/TransitionTests/src/com/android/transitiontests/ListViewAddRemove.java new file mode 100644 index 0000000..f0864dc --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ListViewAddRemove.java @@ -0,0 +1,167 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.view.View; +import android.view.ViewTreeObserver; +import android.view.transition.Fade; +import android.view.transition.Scene; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.LinearLayout; +import android.widget.ListView; +import android.widget.TextView; +import android.view.transition.AutoTransition; +import android.view.transition.Move; +import android.view.transition.Transition; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class ListViewAddRemove extends Activity { + + final ArrayList<String> numList = new ArrayList<String>(); + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.list_view_add_remove); + + final LinearLayout container = (LinearLayout) findViewById(R.id.container); + + final ListView listview = (ListView) findViewById(R.id.listview); + for (int i = 0; i < 200; ++i) { + numList.add(Integer.toString(i)); + } + final StableArrayAdapter adapter = new StableArrayAdapter(this, + android.R.layout.simple_list_item_1, numList); + listview.setAdapter(adapter); + + final ViewTreeObserver observer = container.getViewTreeObserver(); + observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { + public void onGlobalLayout() { + System.out.println("-------------------------------------"); + System.out.println("onLayoutListener: listview view tops: "); + for (int i = 0; i < listview.getChildCount(); ++i) { + TextView view = (TextView) listview.getChildAt(i); + System.out.println(" " + view.getText() + ": " + view.getTop()); + } + } + }); + + final Scene mySceneChanger = new Scene(listview); + + mySceneChanger.setEnterAction(new Runnable() { + @Override + public void run() { + numList.remove(mItemToDelete); + adapter.notifyDataSetChanged(); + } + }); + final Transition myTransition = new AutoTransition(); + final TransitionGroup noFadeIn = new TransitionGroup(TransitionGroup.SEQUENTIALLY); + Fade fadeIn = new Fade(Fade.IN); + fadeIn.setDuration(50); + noFadeIn.addTransitions(new Fade(Fade.OUT), new Move(), fadeIn); + + myTransition.addListener(new Transition.TransitionListenerAdapter() { + @Override + public void onTransitionStart(Transition transition) { + System.out.println("---------ListView Tops: Before--------"); + for (int i = 0; i < listview.getChildCount(); ++i) { + TextView view = (TextView) listview.getChildAt(i); + int position = listview.getPositionForView(view); + } + } + + @Override + public void onTransitionEnd(Transition transition) { + System.out.println("---------ListView Tops: After--------"); + for (int i = 0; i < listview.getChildCount(); ++i) { + TextView view = (TextView) listview.getChildAt(i); + int position = listview.getPositionForView(view); + if (view.hasTransientState()) { +// view.setHasTransientState(false); + } + } + myTransition.removeListener(this); + } + }); + + listview.setOnItemClickListener(new AdapterView.OnItemClickListener() { + + @Override + public void onItemClick(AdapterView<?> parent, final View view, int position, long id) { + System.out.println("---------ListView Tops: OnClick--------"); + String item = (String) parent.getItemAtPosition(position); + for (int i = 0; i < listview.getChildCount(); ++i) { + TextView v = (TextView) listview.getChildAt(i); + if (!item.equals(v.getText())) { +// v.setHasTransientState(true); + } + } +// listview.setHasTransientState(true); + mItemToDelete = item; +// numList.remove(item); + TransitionManager.go(mySceneChanger, noFadeIn); +// view.postDelayed(new Runnable() { +// @Override +// public void run() { +// for (int i = 0; i < listview.getChildCount(); ++i) { +// TextView v = (TextView) listview.getChildAt(i); +// v.setHasTransientState(false); +// } +// } +// }, 200); + } + + }); + } + + String mItemToDelete = null; + + private class StableArrayAdapter extends ArrayAdapter<String> { + + HashMap<String, Integer> mIdMap = new HashMap<String, Integer>(); + + public StableArrayAdapter(Context context, int textViewResourceId, + List<String> objects) { + super(context, textViewResourceId, objects); + for (int i = 0; i < objects.size(); ++i) { + mIdMap.put(objects.get(i), i); + } + } + + @Override + public long getItemId(int position) { + String item = getItem(position); + return mIdMap.get(item); + } + + @Override + public boolean hasStableIds() { + return true; + } + + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ListViewAddRemoveNoTransition.java b/tests/TransitionTests/src/com/android/transitiontests/ListViewAddRemoveNoTransition.java new file mode 100644 index 0000000..93d3d97 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ListViewAddRemoveNoTransition.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.view.View; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.LinearLayout; +import android.widget.ListView; +import android.widget.TextView; +import com.android.transitiontest.R; + + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class ListViewAddRemoveNoTransition extends Activity { + + final ArrayList<String> numList = new ArrayList<String>(); + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.list_view_add_remove); + + final LinearLayout container = (LinearLayout) findViewById(R.id.container); + + final ListView listview = (ListView) findViewById(R.id.listview); + for (int i = 0; i < 200; ++i) { + numList.add(Integer.toString(i)); + } + final StableArrayAdapter adapter = new StableArrayAdapter(this, + android.R.layout.simple_list_item_1, numList); + listview.setAdapter(adapter); + + listview.setOnItemClickListener(new AdapterView.OnItemClickListener() { + + @Override + public void onItemClick(AdapterView<?> parent, final View view, int position, long id) { + String item = (String) parent.getItemAtPosition(position); + for (int i = 0; i < listview.getChildCount(); ++i) { + TextView v = (TextView) listview.getChildAt(i); + if (!item.equals(v.getText())) { + v.setHasTransientState(true); + } + } + numList.remove(item); + adapter.notifyDataSetChanged(); + view.postDelayed(new Runnable() { + @Override + public void run() { + for (int i = 0; i < listview.getChildCount(); ++i) { + TextView v = (TextView) listview.getChildAt(i); + v.setHasTransientState(false); + } + } + }, 200); + } + + }); + } + + private class StableArrayAdapter extends ArrayAdapter<String> { + + HashMap<String, Integer> mIdMap = new HashMap<String, Integer>(); + + public StableArrayAdapter(Context context, int textViewResourceId, + List<String> objects) { + super(context, textViewResourceId, objects); + for (int i = 0; i < objects.size(); ++i) { + mIdMap.put(objects.get(i), i); + } + } + + @Override + public long getItemId(int position) { + String item = getItem(position); + return mIdMap.get(item); + } + + @Override + public boolean hasStableIds() { + return true; + } + + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/LoginActivity.java b/tests/TransitionTests/src/com/android/transitiontests/LoginActivity.java new file mode 100644 index 0000000..d3c5174 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/LoginActivity.java @@ -0,0 +1,105 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.widget.TextView; +import android.view.transition.Fade; +import android.view.transition.Recolor; +import android.view.transition.Slide; +import android.view.transition.Transition; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class LoginActivity extends Activity { + ViewGroup mSceneRoot; + Scene mCurrentScene; + TransitionManager mTransitionManager; + Scene mLoginScene, mPasswordScene, mIncorrectPasswordScene, mSuccessScene, mUsernameTakenScene, + mNewUserScene; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_login); + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mLoginScene = new Scene(mSceneRoot, R.layout.activity_login, this); + mPasswordScene = new Scene(mSceneRoot, R.layout.login_password, this); + mIncorrectPasswordScene = new Scene(mSceneRoot, R.layout.incorrect_password, this); + mUsernameTakenScene = new Scene(mSceneRoot, R.layout.username_taken, this); + mSuccessScene = new Scene(mSceneRoot, R.layout.success, this); + mNewUserScene = new Scene(mSceneRoot, R.layout.new_user, this); + + mTransitionManager = new TransitionManager(); + + // Custom transitions in/out of NewUser screen - slide in the 2nd password UI + TransitionGroup slider = new TransitionGroup(); + slider.addTransitions(new Slide().setTargetIds(R.id.retype, R.id.retypeEdit)); + slider.addTransitions(new Recolor().setTargetIds(R.id.password, R.id.passwordEdit)); + slider.addTransitions(new Fade()); + mTransitionManager.setTransition(mLoginScene, mNewUserScene, slider); + mTransitionManager.setTransition(mPasswordScene, mNewUserScene, slider); + mTransitionManager.setTransition(mNewUserScene, mLoginScene, slider); + mTransitionManager.setTransition(mNewUserScene, mPasswordScene, slider); + + // Custom transitions with recoloring password field + Transition colorizer = new Recolor().setTargetIds(R.id.password, R.id.passwordEdit); + mTransitionManager.setTransition(mLoginScene, mPasswordScene, colorizer); + mTransitionManager.setTransition(mPasswordScene, mLoginScene, colorizer); + + mCurrentScene = mLoginScene; + mSceneRoot.setCurrentScene(mLoginScene); + } + + public void applyScene(Scene scene) { + mTransitionManager.transitionTo(scene); + mCurrentScene = scene; + } + + public void sendMessage(View view) { + TextView textView = (TextView) view; + CharSequence text = textView.getText(); + if (text.equals("Cancel")) { + applyScene(mLoginScene); + } else if (text.equals("Submit")) { + if (mCurrentScene == mLoginScene) { + applyScene(mPasswordScene); + } else if (mCurrentScene == mPasswordScene) { + applyScene(Math.random() < .5 ? mSuccessScene : mIncorrectPasswordScene); + } else if (mCurrentScene == mNewUserScene) { + applyScene(Math.random() < .5 ? mSuccessScene : mUsernameTakenScene); + } + } else if (text.equals("New User?")) { + applyScene(mNewUserScene); + } else if (text.equals("Okay")) { + if (mCurrentScene == mIncorrectPasswordScene) { + applyScene(mPasswordScene); + } else { // username taken scene + applyScene(mNewUserScene); + } + } else if (text.equals("Reset")) { + applyScene(mLoginScene); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/LoginActivityFromResources.java b/tests/TransitionTests/src/com/android/transitiontests/LoginActivityFromResources.java new file mode 100644 index 0000000..fc8aa9b --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/LoginActivityFromResources.java @@ -0,0 +1,94 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.view.transition.TransitionInflater; +import android.widget.TextView; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class LoginActivityFromResources extends Activity { + ViewGroup mSceneRoot; + Scene mCurrentScene; + TransitionManager mTransitionManager = null; + Scene mLoginScene, mPasswordScene, mIncorrectPasswordScene, mSuccessScene, mUsernameTakenScene, + mNewUserScene; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_login); + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + } + + public void applyScene(Scene scene) { + mTransitionManager.transitionTo(scene); + mCurrentScene = scene; + } + + public void sendMessage(View view) { + if (mTransitionManager == null) { + TransitionInflater inflater = TransitionInflater.from(this); + + mLoginScene = inflater.inflateScene(R.scene.login_scene, mSceneRoot); + mPasswordScene = inflater.inflateScene(R.scene.password_scene, mSceneRoot); + mIncorrectPasswordScene = + inflater.inflateScene(R.scene.incorrect_password_scene,mSceneRoot); + mUsernameTakenScene = + inflater.inflateScene(R.scene.username_taken_scene, mSceneRoot); + mSuccessScene = inflater.inflateScene(R.scene.success_scene, mSceneRoot); + mNewUserScene = inflater.inflateScene(R.scene.new_user_scene, mSceneRoot); + + mTransitionManager = + inflater.inflateTransitionManager(R.transition.login_transition_mgr, + mSceneRoot); + + mCurrentScene = mLoginScene; + mSceneRoot.setCurrentScene(mLoginScene); + } + TextView textView = (TextView) view; + CharSequence text = textView.getText(); + if (text.equals("Cancel")) { + applyScene(mLoginScene); + } else if (text.equals("Submit")) { + if (mCurrentScene == mLoginScene) { + applyScene(mPasswordScene); + } else if (mCurrentScene == mPasswordScene) { + applyScene(Math.random() < .5 ? mSuccessScene : mIncorrectPasswordScene); + } else if (mCurrentScene == mNewUserScene) { + applyScene(Math.random() < .5 ? mSuccessScene : mUsernameTakenScene); + } + } else if (text.equals("New User?")) { + applyScene(mNewUserScene); + } else if (text.equals("Okay")) { + if (mCurrentScene == mIncorrectPasswordScene) { + applyScene(mPasswordScene); + } else { // username taken scene + applyScene(mNewUserScene); + } + } else if (text.equals("Reset")) { + applyScene(mLoginScene); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/OverlayTest.java b/tests/TransitionTests/src/com/android/transitiontests/OverlayTest.java new file mode 100644 index 0000000..2f8224a --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/OverlayTest.java @@ -0,0 +1,55 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; +import com.android.transitiontest.R; + + +public class OverlayTest extends Activity { + + ViewGroup mContainer; + ViewGroup mRoot; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.overlay_test); + + mContainer = (ViewGroup) findViewById(R.id.container); + mRoot = (ViewGroup) mContainer.getParent(); + } + + public void onClick(View view) { + final Button fadingButton = (Button) findViewById(R.id.fadingButton); + if (fadingButton != null) { + mContainer.removeView(fadingButton); + mRoot.getOverlay().add(fadingButton); + fadingButton.animate().alpha(0).setDuration(1000).withEndAction(new Runnable() { + @Override + public void run() { + fadingButton.setAlpha(1); + mRoot.getOverlay().remove(fadingButton); + mContainer.addView(fadingButton); + } + }); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/Reparenting.java b/tests/TransitionTests/src/com/android/transitiontests/Reparenting.java new file mode 100644 index 0000000..8ee9d3f --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/Reparenting.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Move; +import android.view.transition.Scene; +import android.view.transition.TransitionManager; +import android.widget.Button; +import com.android.transitiontest.R; + +public class Reparenting extends Activity { + + ViewGroup mSceneRoot; + ViewGroup mContainer1, mContainer2; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.reparenting); + + ViewGroup container = (ViewGroup) findViewById(R.id.container); + mContainer1 = (ViewGroup) findViewById(R.id.container1); + mContainer2 = (ViewGroup) findViewById(R.id.container2); + System.out.println("container 1 and 2 " + mContainer1 + ", " + mContainer2); + + setupButtons(0, mContainer1); + setupButtons(3, mContainer2); + + mSceneRoot = container; + } + + private void setupButtons(int startIndex, ViewGroup parent) { + for (int i = startIndex; i < (startIndex + 3); ++i) { + Button button = new Button(this); + button.setText(Integer.toString(i)); + button.setOnClickListener(mButtonListener); + parent.addView(button); + } + } + + private View.OnClickListener mButtonListener = new View.OnClickListener() { + @Override + public void onClick(final View v) { + Scene newScene = new Scene(mSceneRoot); + newScene.setEnterAction(new Runnable() { + @Override + public void run() { + ViewGroup oldParent = (ViewGroup) v.getParent(); + ViewGroup newParent = oldParent == mContainer1 ? mContainer2 : mContainer1; + oldParent.removeView(v); + newParent.addView(v); + } + }); + Move reparent = new Move(); + reparent.setReparent(true); + TransitionManager.go(newScene, reparent); + } + }; +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ResourceLoadingTest.java b/tests/TransitionTests/src/com/android/transitiontests/ResourceLoadingTest.java new file mode 100644 index 0000000..c05f898 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ResourceLoadingTest.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.view.transition.TransitionInflater; +import android.view.transition.Transition; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class ResourceLoadingTest extends Activity { + + private static final int SEARCH_SCREEN = 0; + private static final int RESULTS_SCREEN = 1; + ViewGroup mSceneRoot; + static int mCurrentScene; + TransitionManager mTransitionManager = null; + TransitionInflater mInflater; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mCurrentScene = SEARCH_SCREEN; + + mInflater = TransitionInflater.from(this); + } + + public void sendMessage(View view) { + if (mTransitionManager == null) { + try { + TransitionInflater inflater = TransitionInflater.from(this); + mTransitionManager = + inflater.inflateTransitionManager(R.transition.my_transition_mgr, + mSceneRoot); + Scene loadedScene = inflater.inflateScene(R.scene.my_scene, mSceneRoot); + System.out.println("loadedScene = " + loadedScene); + Transition loadedTransition = inflater.inflateTransition(R.transition.my_transition); + System.out.println("loadedTransition = " + loadedTransition); + } catch (Exception e) { + System.out.println("Problem loading scene resource: " + e); + } + } + if (mCurrentScene == RESULTS_SCREEN) { + Scene scene = mInflater.inflateScene(R.scene.search_scene, mSceneRoot); + mTransitionManager.transitionTo(scene); + mCurrentScene = SEARCH_SCREEN; + } else { + Scene scene = mInflater.inflateScene(R.scene.results_scene, mSceneRoot); + mTransitionManager.transitionTo(scene); + mCurrentScene = RESULTS_SCREEN; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTargets.java b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTargets.java new file mode 100644 index 0000000..ae8ee5b --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTargets.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Recolor; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class ScenesTestAutoTargets extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + TransitionManager mTransitionManager = null; + Scene mResultsScreen, mSearchScreen; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + + TransitionGroup transition = new TransitionGroup(); + transition.addTransitions(new Fade(), new Move(), new Recolor()); + + mTransitionManager = new TransitionManager(); + mTransitionManager.setTransition(mSearchScreen, transition); + mTransitionManager.setTransition(mResultsScreen, transition); + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + mTransitionManager.transitionTo(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + mTransitionManager.transitionTo(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTransition.java b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTransition.java new file mode 100644 index 0000000..9184e87 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTransition.java @@ -0,0 +1,57 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.AutoTransition; +import android.view.transition.Scene; +import android.view.transition.Transition; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class ScenesTestAutoTransition extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + Transition mTransition = new AutoTransition(); + Scene mResultsScreen, mSearchScreen; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + TransitionManager.go(mSearchScreen, mTransition); + mCurrentScene = mSearchScreen; + } else { + TransitionManager.go(mResultsScreen, mTransition); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTransition2.java b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTransition2.java new file mode 100644 index 0000000..fc8acc1 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestAutoTransition2.java @@ -0,0 +1,55 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class ScenesTestAutoTransition2 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + + Scene mResultsScreen, mSearchScreen; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + TransitionManager.go(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + TransitionManager.go(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/ScenesTestv21.java b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestv21.java new file mode 100644 index 0000000..2dae463 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/ScenesTestv21.java @@ -0,0 +1,75 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Recolor; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class ScenesTestv21 extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + TransitionManager mTransitionManager = null; + Scene mResultsScreen, mSearchScreen; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.search_screen); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mSearchScreen = new Scene(mSceneRoot, R.layout.search_screen, this); + mResultsScreen = new Scene(mSceneRoot, R.layout.results_screen, this); + + TransitionGroup transitionToResults = new TransitionGroup(); + Fade fade = new Fade(); + fade.setTargetIds(R.id.resultsText, R.id.resultsList); + fade.setStartDelay(300); + transitionToResults.addTransitions(fade); + transitionToResults.addTransitions(new Move().setTargetIds(R.id.searchContainer)); + transitionToResults.addTransitions(new Recolor().setTargetIds(R.id.container)); + + TransitionGroup transitionToSearch = new TransitionGroup(); + transitionToSearch.addTransitions(new Fade().setTargetIds(R.id.resultsText, R.id.resultsList)); + transitionToSearch.addTransitions(new Move().setTargetIds(R.id.searchContainer)); + transitionToSearch.addTransitions(new Recolor().setTargetIds(R.id.container)); + mTransitionManager = new TransitionManager(); + mTransitionManager.setTransition(mSearchScreen, transitionToSearch); + mTransitionManager.setTransition(mResultsScreen, transitionToResults); + } + + public void sendMessage(View view) { + if (mCurrentScene == mResultsScreen) { + mTransitionManager.transitionTo(mSearchScreen); + mCurrentScene = mSearchScreen; + } else { + mTransitionManager.transitionTo(mResultsScreen); + mCurrentScene = mResultsScreen; + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/SequenceTest.java b/tests/TransitionTests/src/com/android/transitiontests/SequenceTest.java new file mode 100644 index 0000000..8cb6a1a --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/SequenceTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.view.transition.Transition; +import android.widget.Button; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class SequenceTest extends Activity { + + Button mRemovingButton, mInvisibleButton, mGoneButton; + Scene mScene1, mScene2; + ViewGroup mSceneRoot; + TransitionGroup sequencedFade, reverseSequencedFade; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.fading_test); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mRemovingButton = (Button) findViewById(R.id.removingButton); + mInvisibleButton = (Button) findViewById(R.id.invisibleButton); + mGoneButton = (Button) findViewById(R.id.goneButton); + + mScene1 = new Scene(mSceneRoot, R.layout.fading_test, this); + mScene2 = new Scene(mSceneRoot, R.layout.fading_test_scene_2, this); + + Transition fade1 = new Fade().setTargetIds(R.id.removingButton); + Transition fade2 = new Fade().setTargetIds(R.id.invisibleButton); + Transition fade3 = new Fade().setTargetIds(R.id.goneButton); + TransitionGroup fader = new TransitionGroup(TransitionGroup.SEQUENTIALLY); + fader.addTransitions(fade1, fade2, fade3, new Move()); + sequencedFade = fader; + + reverseSequencedFade = new TransitionGroup(TransitionGroup.SEQUENTIALLY); + reverseSequencedFade.addTransitions(new Move(), fade3, fade2, fade1); + + mSceneRoot.setCurrentScene(mScene1); + } + + public void sendMessage(View view) { + if (mSceneRoot.getCurrentScene() == mScene1) { + TransitionManager.go(mScene2, sequencedFade); + } else { + TransitionManager.go(mScene1, reverseSequencedFade); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/SequenceTestSimple.java b/tests/TransitionTests/src/com/android/transitiontests/SequenceTestSimple.java new file mode 100644 index 0000000..93bfdb4 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/SequenceTestSimple.java @@ -0,0 +1,71 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.widget.Button; +import android.view.transition.Fade; +import android.view.transition.Move; +import android.view.transition.Transition; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +public class SequenceTestSimple extends Activity { + + Button mRemovingButton, mInvisibleButton, mGoneButton; + Scene mScene1, mScene2; + ViewGroup mSceneRoot; + Transition sequencedFade; + TransitionGroup sequencedFadeReverse; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.fading_test_simple); + + View container = (View) findViewById(R.id.container); + mSceneRoot = (ViewGroup) container.getParent(); + + mRemovingButton = (Button) findViewById(R.id.removingButton); + + mScene1 = new Scene(mSceneRoot, R.layout.fading_test_simple, this); + mScene2 = new Scene(mSceneRoot, R.layout.fading_test_simple2, this); + + TransitionGroup fader = new TransitionGroup(TransitionGroup.SEQUENTIALLY); + fader.addTransitions(new Fade().setTargetIds(R.id.removingButton)); + fader.addTransitions(new Move().setTargetIds(R.id.sceneSwitchButton)); + sequencedFade = fader; + + sequencedFadeReverse = new TransitionGroup(TransitionGroup.SEQUENTIALLY); + sequencedFadeReverse.addTransitions(new Move().setTargetIds(R.id.sceneSwitchButton)); + sequencedFadeReverse.addTransitions(new Fade().setTargetIds(R.id.removingButton)); + + mSceneRoot.setCurrentScene(mScene1); + } + + public void sendMessage(View view) { + if (mSceneRoot.getCurrentScene() == mScene1) { + TransitionManager.go(mScene2, sequencedFade); + } else { + TransitionManager.go(mScene1, sequencedFadeReverse); + } + }} diff --git a/tests/TransitionTests/src/com/android/transitiontests/SurfaceAndTextureViews.java b/tests/TransitionTests/src/com/android/transitiontests/SurfaceAndTextureViews.java new file mode 100644 index 0000000..f8829c9 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/SurfaceAndTextureViews.java @@ -0,0 +1,195 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.content.Context; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.SurfaceTexture; +import android.os.Bundle; +import android.util.AttributeSet; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.TextureView; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Crossfade; +import android.view.transition.Move; +import android.view.transition.Scene; +import android.view.transition.TransitionGroup; +import android.view.transition.TransitionManager; +import android.widget.Button; +import com.android.transitiontest.R; + +import static android.widget.LinearLayout.LayoutParams; + +public class SurfaceAndTextureViews extends Activity { + + SimpleView mView; + SimpleSurfaceView mSurfaceView; + SimpleTextureView mTextureView; + private static final int SMALL_SIZE = 200; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.surface_texture_views); + + final ViewGroup container = (ViewGroup) findViewById(R.id.container); + Button toggleButton = (Button) findViewById(R.id.toggleButton); + + mView = new SimpleView(this); + mView.setId(0); + mView.setLayoutParams(new LayoutParams(SMALL_SIZE, SMALL_SIZE)); + container.addView(mView); + + mSurfaceView = new SimpleSurfaceView(this); + mSurfaceView.setId(1); + mSurfaceView.setLayoutParams(new LayoutParams(SMALL_SIZE, SMALL_SIZE)); + container.addView(mSurfaceView); + + mTextureView = new SimpleTextureView(this); + mTextureView.setId(2); + mTextureView.setLayoutParams(new LayoutParams(SMALL_SIZE, SMALL_SIZE)); + container.addView(mTextureView); + + final TransitionGroup transition = new TransitionGroup(); + transition.addTransitions(new Move(), new Crossfade().setTargetIds(0, 1, 2)); + + toggleButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + Scene newScene = new Scene(container); + newScene.setEnterAction(new Runnable() { + @Override + public void run() { + if (mView.getWidth() <= SMALL_SIZE) { + mView.setLayoutParams(new LayoutParams(SMALL_SIZE * 2, SMALL_SIZE)); + mSurfaceView.setLayoutParams(new LayoutParams(SMALL_SIZE * 2, SMALL_SIZE)); + mTextureView.setLayoutParams(new LayoutParams(SMALL_SIZE * 2, SMALL_SIZE)); + mView.mColor = SimpleView.LARGE_COLOR; + mSurfaceView.mColor = SimpleSurfaceView.LARGE_COLOR; + mTextureView.mColor = SimpleTextureView.LARGE_COLOR; + } else { + mView.setLayoutParams(new LayoutParams(SMALL_SIZE, SMALL_SIZE)); + mSurfaceView.setLayoutParams(new LayoutParams(SMALL_SIZE, SMALL_SIZE)); + mTextureView.setLayoutParams(new LayoutParams(SMALL_SIZE, SMALL_SIZE)); + mView.mColor = SimpleView.SMALL_COLOR; + mSurfaceView.mColor = SimpleSurfaceView.SMALL_COLOR; + mTextureView.mColor = SimpleTextureView.SMALL_COLOR; + } + } + }); + TransitionManager.go(newScene, transition); + } + }); + + } + + static private class SimpleView extends View { + static final int SMALL_COLOR = Color.BLUE; + static final int LARGE_COLOR = Color.YELLOW; + int mColor = SMALL_COLOR; + + private SimpleView(Context context) { + super(context); + } + + @Override + protected void onDraw(Canvas canvas) { + canvas.drawColor(mColor); + } + } + + static private class SimpleSurfaceView extends SurfaceView implements SurfaceHolder.Callback { + + static final int SMALL_COLOR = Color.GREEN; + static final int LARGE_COLOR = Color.GRAY; + int mColor = SMALL_COLOR; + SurfaceHolder mHolder = null; + + private SimpleSurfaceView(Context context) { + super(context); + SurfaceHolder holder = getHolder(); + holder.addCallback(this); + } + + + @Override + public void surfaceCreated(SurfaceHolder holder) { + System.out.println("surfaceCreated"); + } + + @Override + public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { + System.out.println("surfaceChanged: w h = " + width + ", " + height); + Canvas canvas = holder.lockCanvas(); + canvas.drawColor(mColor); + holder.unlockCanvasAndPost(canvas); + } + + @Override + public void surfaceDestroyed(SurfaceHolder holder) { + System.out.println("surfaceDestroyed"); + } + } + + static private class SimpleTextureView extends TextureView implements TextureView.SurfaceTextureListener { + + static final int SMALL_COLOR = Color.RED; + static final int LARGE_COLOR = Color.CYAN; + int mColor = SMALL_COLOR; + + private SimpleTextureView(Context context) { + super(context); + setSurfaceTextureListener(this); + } + + private SimpleTextureView(Context context, AttributeSet attrs) { + super(context, attrs); + setSurfaceTextureListener(this); + } + + private SimpleTextureView(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + setSurfaceTextureListener(this); + } + + @Override + public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) { + System.out.println("SurfaceTexture available"); + } + + @Override + public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { + System.out.println("SurfaceTexture size changed to " + width + ", " + height); + Canvas canvas = lockCanvas(); + canvas.drawColor(mColor); + unlockCanvasAndPost(canvas); + } + + @Override + public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { + return false; + } + + @Override + public void onSurfaceTextureUpdated(SurfaceTexture surface) { + System.out.println("SurfaceTexture updated"); + } + } +} diff --git a/tests/TransitionTests/src/com/android/transitiontests/UniqueIds.java b/tests/TransitionTests/src/com/android/transitiontests/UniqueIds.java new file mode 100644 index 0000000..18537c7 --- /dev/null +++ b/tests/TransitionTests/src/com/android/transitiontests/UniqueIds.java @@ -0,0 +1,86 @@ +/* + * Copyright (C) 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.android.transitiontests; + +import android.app.Activity; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.transition.Scene; +import android.view.transition.Transition; +import android.widget.Button; +import android.widget.LinearLayout; +import android.view.transition.TransitionManager; +import com.android.transitiontest.R; + + +import java.util.HashMap; + +public class UniqueIds extends Activity { + ViewGroup mSceneRoot; + static Scene mCurrentScene; + TransitionManager mTransitionManager = null; + HashMap<Button, ToggleScene> mSceneMap = new HashMap<Button, ToggleScene>(); + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.unique_id_test); + + LinearLayout container = (LinearLayout) findViewById(R.id.container); + LayoutInflater inflater = getLayoutInflater(); + Button button = (Button) inflater.inflate(R.layout.button_template, null); + container.addView(button); + ToggleScene scene = new ToggleScene(container, button); + mSceneMap.put(button, scene); + button = (Button) inflater.inflate(R.layout.button_template, null); + container.addView(button); + scene = new ToggleScene(container, button); + mSceneMap.put(button, scene); + } + + public void sendMessage(View view) { + mSceneMap.get(view).changeToScene(); + } + + class ToggleScene { + Scene mScene; + Transition mTransition; + Button mButton; + + ToggleScene(ViewGroup rootView, Button button) { + mScene = new Scene(rootView); + mButton = button; + mScene.setEnterAction(new Runnable() { + @Override + public void run() { + if (mButton.getLeft() == 0) { + mButton.offsetLeftAndRight(500); + } else { + int width = mButton.getWidth(); + mButton.setLeft(0); + mButton.setRight(width); + } + } + }); + } + + void changeToScene() { + TransitionManager.go(mScene); + } + } +} |