Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.launcher2; |
| 18 | |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 19 | import android.animation.Animator; |
Winson Chung | b44b524 | 2011-06-13 11:32:14 -0700 | [diff] [blame] | 20 | import android.animation.AnimatorListenerAdapter; |
Winson Chung | f314b0e | 2011-08-16 11:54:27 -0700 | [diff] [blame] | 21 | import android.animation.AnimatorSet; |
Winson Chung | b44b524 | 2011-06-13 11:32:14 -0700 | [diff] [blame] | 22 | import android.animation.ObjectAnimator; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 23 | import android.content.Context; |
| 24 | import android.content.res.Resources; |
| 25 | import android.util.AttributeSet; |
| 26 | import android.view.LayoutInflater; |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 27 | import android.view.MotionEvent; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 28 | import android.view.View; |
| 29 | import android.view.ViewGroup; |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 30 | import android.widget.FrameLayout; |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 31 | import android.widget.LinearLayout; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 32 | import android.widget.TabHost; |
Winson Chung | faa1325 | 2011-06-13 18:15:54 -0700 | [diff] [blame] | 33 | import android.widget.TabWidget; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 34 | import android.widget.TextView; |
| 35 | |
| 36 | import com.android.launcher.R; |
| 37 | |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 38 | import java.util.ArrayList; |
| 39 | |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 40 | public class AppsCustomizeTabHost extends TabHost implements LauncherTransitionable, |
| 41 | TabHost.OnTabChangeListener { |
| 42 | static final String LOG_TAG = "AppsCustomizeTabHost"; |
| 43 | |
| 44 | private static final String APPS_TAB_TAG = "APPS"; |
| 45 | private static final String WIDGETS_TAB_TAG = "WIDGETS"; |
| 46 | |
| 47 | private final LayoutInflater mLayoutInflater; |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 48 | private ViewGroup mTabs; |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 49 | private ViewGroup mTabsContainer; |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 50 | private AppsCustomizePagedView mAppsCustomizePane; |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 51 | private boolean mSuppressContentCallback = false; |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 52 | private FrameLayout mAnimationBuffer; |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 53 | private LinearLayout mContent; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 54 | |
Winson Chung | c100e8e | 2011-08-09 16:02:43 -0700 | [diff] [blame] | 55 | private boolean mInTransition; |
Winson Chung | 7044272 | 2012-02-10 15:43:22 -0800 | [diff] [blame] | 56 | private boolean mTransitioningToWorkspace; |
Winson Chung | c100e8e | 2011-08-09 16:02:43 -0700 | [diff] [blame] | 57 | private boolean mResetAfterTransition; |
Michael Jurka | 6cfafb9 | 2012-02-23 18:25:43 -0800 | [diff] [blame] | 58 | private Runnable mRelayoutAndMakeVisible; |
Winson Chung | c100e8e | 2011-08-09 16:02:43 -0700 | [diff] [blame] | 59 | |
Winson Chung | c7450e3 | 2012-04-17 17:34:08 -0700 | [diff] [blame] | 60 | private Launcher mLauncher; |
| 61 | |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 62 | public AppsCustomizeTabHost(Context context, AttributeSet attrs) { |
| 63 | super(context, attrs); |
| 64 | mLayoutInflater = LayoutInflater.from(context); |
Michael Jurka | 6cfafb9 | 2012-02-23 18:25:43 -0800 | [diff] [blame] | 65 | mRelayoutAndMakeVisible = new Runnable() { |
| 66 | public void run() { |
| 67 | mTabs.requestLayout(); |
| 68 | mTabsContainer.setAlpha(1f); |
| 69 | } |
| 70 | }; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 71 | } |
| 72 | |
Winson Chung | c7450e3 | 2012-04-17 17:34:08 -0700 | [diff] [blame] | 73 | public void setup(Launcher launcher) { |
| 74 | mLauncher = launcher; |
| 75 | } |
| 76 | |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 77 | /** |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 78 | * Convenience methods to select specific tabs. We want to set the content type immediately |
| 79 | * in these cases, but we note that we still call setCurrentTabByTag() so that the tab view |
| 80 | * reflects the new content (but doesn't do the animation and logic associated with changing |
| 81 | * tabs manually). |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 82 | */ |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 83 | private void setContentTypeImmediate(AppsCustomizePagedView.ContentType type) { |
| 84 | onTabChangedStart(); |
| 85 | onTabChangedEnd(type); |
| 86 | } |
Winson Chung | 55b6550 | 2011-05-26 12:03:43 -0700 | [diff] [blame] | 87 | void selectAppsTab() { |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 88 | setContentTypeImmediate(AppsCustomizePagedView.ContentType.Applications); |
Winson Chung | 55b6550 | 2011-05-26 12:03:43 -0700 | [diff] [blame] | 89 | setCurrentTabByTag(APPS_TAB_TAG); |
| 90 | } |
| 91 | void selectWidgetsTab() { |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 92 | setContentTypeImmediate(AppsCustomizePagedView.ContentType.Widgets); |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 93 | setCurrentTabByTag(WIDGETS_TAB_TAG); |
| 94 | } |
Winson Chung | 55b6550 | 2011-05-26 12:03:43 -0700 | [diff] [blame] | 95 | |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 96 | /** |
| 97 | * Setup the tab host and create all necessary tabs. |
| 98 | */ |
| 99 | @Override |
| 100 | protected void onFinishInflate() { |
| 101 | // Setup the tab host |
| 102 | setup(); |
| 103 | |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 104 | final ViewGroup tabsContainer = (ViewGroup) findViewById(R.id.tabs_container); |
Michael Jurka | 8b805b1 | 2012-04-18 14:23:14 -0700 | [diff] [blame] | 105 | final TabWidget tabs = getTabWidget(); |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 106 | final AppsCustomizePagedView appsCustomizePane = (AppsCustomizePagedView) |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 107 | findViewById(R.id.apps_customize_pane_content); |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 108 | mTabs = tabs; |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 109 | mTabsContainer = tabsContainer; |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 110 | mAppsCustomizePane = appsCustomizePane; |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 111 | mAnimationBuffer = (FrameLayout) findViewById(R.id.animation_buffer); |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 112 | mContent = (LinearLayout) findViewById(R.id.apps_customize_content); |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 113 | if (tabs == null || mAppsCustomizePane == null) throw new Resources.NotFoundException(); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 114 | |
| 115 | // Configure the tabs content factory to return the same paged view (that we change the |
| 116 | // content filter on) |
| 117 | TabContentFactory contentFactory = new TabContentFactory() { |
| 118 | public View createTabContent(String tag) { |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 119 | return appsCustomizePane; |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 120 | } |
| 121 | }; |
| 122 | |
| 123 | // Create the tabs |
| 124 | TextView tabView; |
Winson Chung | d2c1f80 | 2011-10-14 12:26:54 -0700 | [diff] [blame] | 125 | String label; |
Michael Jurka | 8b805b1 | 2012-04-18 14:23:14 -0700 | [diff] [blame] | 126 | label = getContext().getString(R.string.all_apps_button_label); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 127 | tabView = (TextView) mLayoutInflater.inflate(R.layout.tab_widget_indicator, tabs, false); |
Winson Chung | d2c1f80 | 2011-10-14 12:26:54 -0700 | [diff] [blame] | 128 | tabView.setText(label); |
| 129 | tabView.setContentDescription(label); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 130 | addTab(newTabSpec(APPS_TAB_TAG).setIndicator(tabView).setContent(contentFactory)); |
Michael Jurka | 8b805b1 | 2012-04-18 14:23:14 -0700 | [diff] [blame] | 131 | label = getContext().getString(R.string.widgets_tab_label); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 132 | tabView = (TextView) mLayoutInflater.inflate(R.layout.tab_widget_indicator, tabs, false); |
Winson Chung | d2c1f80 | 2011-10-14 12:26:54 -0700 | [diff] [blame] | 133 | tabView.setText(label); |
| 134 | tabView.setContentDescription(label); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 135 | addTab(newTabSpec(WIDGETS_TAB_TAG).setIndicator(tabView).setContent(contentFactory)); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 136 | setOnTabChangedListener(this); |
Winson Chung | faa1325 | 2011-06-13 18:15:54 -0700 | [diff] [blame] | 137 | |
| 138 | // Setup the key listener to jump between the last tab view and the market icon |
| 139 | AppsCustomizeTabKeyEventListener keyListener = new AppsCustomizeTabKeyEventListener(); |
| 140 | View lastTab = tabs.getChildTabViewAt(tabs.getTabCount() - 1); |
| 141 | lastTab.setOnKeyListener(keyListener); |
| 142 | View shopButton = findViewById(R.id.market_button); |
| 143 | shopButton.setOnKeyListener(keyListener); |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 144 | |
| 145 | // Hide the tab bar until we measure |
| 146 | mTabsContainer.setAlpha(0f); |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 147 | } |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 148 | |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 149 | @Override |
| 150 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| 151 | boolean remeasureTabWidth = (mTabs.getLayoutParams().width <= 0); |
| 152 | super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| 153 | |
| 154 | // Set the width of the tab list to the content width |
| 155 | if (remeasureTabWidth) { |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 156 | int contentWidth = mAppsCustomizePane.getPageContentWidth(); |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 157 | if (contentWidth > 0 && mTabs.getLayoutParams().width != contentWidth) { |
| 158 | // Set the width and show the tab bar |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 159 | mTabs.getLayoutParams().width = contentWidth; |
Michael Jurka | 6cfafb9 | 2012-02-23 18:25:43 -0800 | [diff] [blame] | 160 | post(mRelayoutAndMakeVisible); |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 161 | } |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 162 | } |
Winson Chung | fd3385f | 2011-06-15 19:51:24 -0700 | [diff] [blame] | 163 | super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 164 | } |
| 165 | |
Winson Chung | 7044272 | 2012-02-10 15:43:22 -0800 | [diff] [blame] | 166 | public boolean onInterceptTouchEvent(MotionEvent ev) { |
Winson Chung | ac08f4b | 2012-04-27 15:41:00 -0700 | [diff] [blame] | 167 | // If we are mid transitioning to the workspace, then intercept touch events here so we |
| 168 | // can ignore them, otherwise we just let all apps handle the touch events. |
| 169 | if (mInTransition && mTransitioningToWorkspace) { |
Winson Chung | 7044272 | 2012-02-10 15:43:22 -0800 | [diff] [blame] | 170 | return true; |
| 171 | } |
| 172 | return super.onInterceptTouchEvent(ev); |
| 173 | }; |
| 174 | |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 175 | @Override |
| 176 | public boolean onTouchEvent(MotionEvent event) { |
Winson Chung | ac08f4b | 2012-04-27 15:41:00 -0700 | [diff] [blame] | 177 | // Allow touch events to fall through to the workspace if we are transitioning there |
| 178 | if (mInTransition && mTransitioningToWorkspace) { |
Winson Chung | 21fadea | 2012-04-27 15:59:55 -0700 | [diff] [blame] | 179 | return super.onTouchEvent(event); |
Winson Chung | 7044272 | 2012-02-10 15:43:22 -0800 | [diff] [blame] | 180 | } |
| 181 | |
Winson Chung | 4179b4e | 2011-05-31 17:28:12 -0700 | [diff] [blame] | 182 | // Intercept all touch events up to the bottom of the AppsCustomizePane so they do not fall |
| 183 | // through to the workspace and trigger showWorkspace() |
| 184 | if (event.getY() < mAppsCustomizePane.getBottom()) { |
| 185 | return true; |
| 186 | } |
| 187 | return super.onTouchEvent(event); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 188 | } |
| 189 | |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 190 | private void onTabChangedStart() { |
| 191 | mAppsCustomizePane.hideScrollingIndicator(false); |
| 192 | } |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 193 | |
Winson Chung | 097e6c7 | 2011-10-20 13:58:30 -0700 | [diff] [blame] | 194 | private void reloadCurrentPage() { |
| 195 | if (!LauncherApplication.isScreenLarge()) { |
Michael Jurka | b737ee6 | 2011-11-15 15:57:22 -0800 | [diff] [blame] | 196 | mAppsCustomizePane.flashScrollingIndicator(true); |
Winson Chung | 097e6c7 | 2011-10-20 13:58:30 -0700 | [diff] [blame] | 197 | } |
| 198 | mAppsCustomizePane.loadAssociatedPages(mAppsCustomizePane.getCurrentPage()); |
| 199 | mAppsCustomizePane.requestFocus(); |
| 200 | } |
| 201 | |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 202 | private void onTabChangedEnd(AppsCustomizePagedView.ContentType type) { |
| 203 | mAppsCustomizePane.setContentType(type); |
| 204 | } |
| 205 | |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 206 | @Override |
| 207 | public void onTabChanged(String tabId) { |
Winson Chung | b44b524 | 2011-06-13 11:32:14 -0700 | [diff] [blame] | 208 | final AppsCustomizePagedView.ContentType type = getContentTypeForTabTag(tabId); |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 209 | if (mSuppressContentCallback) { |
| 210 | mSuppressContentCallback = false; |
| 211 | return; |
Winson Chung | b44b524 | 2011-06-13 11:32:14 -0700 | [diff] [blame] | 212 | } |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 213 | |
| 214 | // Animate the changing of the tab content by fading pages in and out |
| 215 | final Resources res = getResources(); |
| 216 | final int duration = res.getInteger(R.integer.config_tabTransitionDuration); |
| 217 | |
| 218 | // We post a runnable here because there is a delay while the first page is loading and |
| 219 | // the feedback from having changed the tab almost feels better than having it stick |
| 220 | post(new Runnable() { |
| 221 | @Override |
| 222 | public void run() { |
Winson Chung | 097e6c7 | 2011-10-20 13:58:30 -0700 | [diff] [blame] | 223 | if (mAppsCustomizePane.getMeasuredWidth() <= 0 || |
| 224 | mAppsCustomizePane.getMeasuredHeight() <= 0) { |
| 225 | reloadCurrentPage(); |
| 226 | return; |
| 227 | } |
| 228 | |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 229 | // Take the visible pages and re-parent them temporarily to mAnimatorBuffer |
| 230 | // and then cross fade to the new pages |
Winson Chung | c6f10b9 | 2011-11-14 11:39:07 -0800 | [diff] [blame] | 231 | int[] visiblePageRange = new int[2]; |
| 232 | mAppsCustomizePane.getVisiblePages(visiblePageRange); |
| 233 | if (visiblePageRange[0] == -1 && visiblePageRange[1] == -1) { |
| 234 | // If we can't get the visible page ranges, then just skip the animation |
| 235 | reloadCurrentPage(); |
| 236 | return; |
| 237 | } |
| 238 | ArrayList<View> visiblePages = new ArrayList<View>(); |
| 239 | for (int i = visiblePageRange[0]; i <= visiblePageRange[1]; i++) { |
| 240 | visiblePages.add(mAppsCustomizePane.getPageAt(i)); |
| 241 | } |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 242 | |
| 243 | // We want the pages to be rendered in exactly the same way as they were when |
| 244 | // their parent was mAppsCustomizePane -- so set the scroll on mAnimationBuffer |
| 245 | // to be exactly the same as mAppsCustomizePane, and below, set the left/top |
| 246 | // parameters to be correct for each of the pages |
| 247 | mAnimationBuffer.scrollTo(mAppsCustomizePane.getScrollX(), 0); |
| 248 | |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 249 | // mAppsCustomizePane renders its children in reverse order, so |
| 250 | // add the pages to mAnimationBuffer in reverse order to match that behavior |
| 251 | for (int i = visiblePages.size() - 1; i >= 0; i--) { |
| 252 | View child = visiblePages.get(i); |
Winson Chung | c6f10b9 | 2011-11-14 11:39:07 -0800 | [diff] [blame] | 253 | if (child instanceof PagedViewCellLayout) { |
| 254 | ((PagedViewCellLayout) child).resetChildrenOnKeyListeners(); |
| 255 | } else if (child instanceof PagedViewGridLayout) { |
| 256 | ((PagedViewGridLayout) child).resetChildrenOnKeyListeners(); |
| 257 | } |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 258 | PagedViewWidget.setDeletePreviewsWhenDetachedFromWindow(false); |
| 259 | mAppsCustomizePane.removeView(child); |
| 260 | PagedViewWidget.setDeletePreviewsWhenDetachedFromWindow(true); |
| 261 | mAnimationBuffer.setAlpha(1f); |
| 262 | mAnimationBuffer.setVisibility(View.VISIBLE); |
Winson Chung | 6e3cf90 | 2012-03-30 16:36:53 -0700 | [diff] [blame] | 263 | LayoutParams p = new FrameLayout.LayoutParams(child.getMeasuredWidth(), |
| 264 | child.getMeasuredHeight()); |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 265 | p.setMargins((int) child.getLeft(), (int) child.getTop(), 0, 0); |
| 266 | mAnimationBuffer.addView(child, p); |
| 267 | } |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 268 | |
| 269 | // Toggle the new content |
| 270 | onTabChangedStart(); |
| 271 | onTabChangedEnd(type); |
| 272 | |
| 273 | // Animate the transition |
| 274 | ObjectAnimator outAnim = ObjectAnimator.ofFloat(mAnimationBuffer, "alpha", 0f); |
| 275 | outAnim.addListener(new AnimatorListenerAdapter() { |
| 276 | @Override |
| 277 | public void onAnimationEnd(Animator animation) { |
| 278 | mAnimationBuffer.setVisibility(View.GONE); |
Michael Jurka | 141dbd0 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 279 | mAnimationBuffer.removeAllViews(); |
| 280 | } |
| 281 | @Override |
| 282 | public void onAnimationCancel(Animator animation) { |
| 283 | mAnimationBuffer.setVisibility(View.GONE); |
| 284 | mAnimationBuffer.removeAllViews(); |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 285 | } |
| 286 | }); |
| 287 | ObjectAnimator inAnim = ObjectAnimator.ofFloat(mAppsCustomizePane, "alpha", 1f); |
| 288 | inAnim.addListener(new AnimatorListenerAdapter() { |
| 289 | @Override |
| 290 | public void onAnimationEnd(Animator animation) { |
Winson Chung | 097e6c7 | 2011-10-20 13:58:30 -0700 | [diff] [blame] | 291 | reloadCurrentPage(); |
Adam Cohen | 0cd3b64 | 2011-10-14 14:58:00 -0700 | [diff] [blame] | 292 | } |
| 293 | }); |
| 294 | AnimatorSet animSet = new AnimatorSet(); |
| 295 | animSet.playTogether(outAnim, inAnim); |
| 296 | animSet.setDuration(duration); |
| 297 | animSet.start(); |
| 298 | } |
| 299 | }); |
| 300 | } |
| 301 | |
| 302 | public void setCurrentTabFromContent(AppsCustomizePagedView.ContentType type) { |
| 303 | mSuppressContentCallback = true; |
| 304 | setCurrentTabByTag(getTabTagForContentType(type)); |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | /** |
| 308 | * Returns the content type for the specified tab tag. |
| 309 | */ |
| 310 | public AppsCustomizePagedView.ContentType getContentTypeForTabTag(String tag) { |
| 311 | if (tag.equals(APPS_TAB_TAG)) { |
| 312 | return AppsCustomizePagedView.ContentType.Applications; |
| 313 | } else if (tag.equals(WIDGETS_TAB_TAG)) { |
| 314 | return AppsCustomizePagedView.ContentType.Widgets; |
| 315 | } |
| 316 | return AppsCustomizePagedView.ContentType.Applications; |
| 317 | } |
| 318 | |
| 319 | /** |
Winson Chung | fc79c80 | 2011-05-02 13:35:34 -0700 | [diff] [blame] | 320 | * Returns the tab tag for a given content type. |
| 321 | */ |
| 322 | public String getTabTagForContentType(AppsCustomizePagedView.ContentType type) { |
| 323 | if (type == AppsCustomizePagedView.ContentType.Applications) { |
| 324 | return APPS_TAB_TAG; |
| 325 | } else if (type == AppsCustomizePagedView.ContentType.Widgets) { |
| 326 | return WIDGETS_TAB_TAG; |
| 327 | } |
| 328 | return APPS_TAB_TAG; |
| 329 | } |
| 330 | |
| 331 | /** |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 332 | * Disable focus on anything under this view in the hierarchy if we are not visible. |
| 333 | */ |
| 334 | @Override |
| 335 | public int getDescendantFocusability() { |
| 336 | if (getVisibility() != View.VISIBLE) { |
| 337 | return ViewGroup.FOCUS_BLOCK_DESCENDANTS; |
| 338 | } |
| 339 | return super.getDescendantFocusability(); |
| 340 | } |
| 341 | |
Winson Chung | c100e8e | 2011-08-09 16:02:43 -0700 | [diff] [blame] | 342 | void reset() { |
| 343 | if (mInTransition) { |
| 344 | // Defer to after the transition to reset |
| 345 | mResetAfterTransition = true; |
| 346 | } else { |
| 347 | // Reset immediately |
| 348 | mAppsCustomizePane.reset(); |
| 349 | } |
| 350 | } |
| 351 | |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 352 | private void enableAndBuildHardwareLayer() { |
Michael Jurka | 19e0fc5 | 2011-07-22 18:00:21 -0700 | [diff] [blame] | 353 | // isHardwareAccelerated() checks if we're attached to a window and if that |
| 354 | // window is HW accelerated-- we were sometimes not attached to a window |
| 355 | // and buildLayer was throwing an IllegalStateException |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 356 | if (isHardwareAccelerated()) { |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 357 | // Turn on hardware layers for performance |
| 358 | setLayerType(LAYER_TYPE_HARDWARE, null); |
| 359 | |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 360 | // force building the layer, so you don't get a blip early in an animation |
| 361 | // when the layer is created layer |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 362 | buildLayer(); |
Michael Jurka | 39e5d17 | 2012-03-12 18:36:12 -0700 | [diff] [blame] | 363 | |
| 364 | // Let the GC system know that now is a good time to do any garbage |
| 365 | // collection; makes it less likely we'll get a GC during the all apps |
| 366 | // to workspace animation |
| 367 | System.gc(); |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 368 | } |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 369 | } |
| 370 | |
Michael Jurka | 2a4b1a8 | 2011-12-07 14:00:02 -0800 | [diff] [blame] | 371 | @Override |
| 372 | public View getContent() { |
| 373 | return mContent; |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 374 | } |
| 375 | |
| 376 | /* LauncherTransitionable overrides */ |
| 377 | @Override |
Michael Jurka | a35e35a | 2012-04-26 15:04:28 -0700 | [diff] [blame] | 378 | public void onLauncherTransitionPrepare(Launcher l, boolean animated, boolean toWorkspace) { |
| 379 | mAppsCustomizePane.onLauncherTransitionPrepare(l, animated, toWorkspace); |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 380 | mInTransition = true; |
Winson Chung | 7044272 | 2012-02-10 15:43:22 -0800 | [diff] [blame] | 381 | mTransitioningToWorkspace = toWorkspace; |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 382 | |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 383 | if (toWorkspace) { |
| 384 | // Going from All Apps -> Workspace |
| 385 | setVisibilityOfSiblingsWithLowerZOrder(VISIBLE); |
Michael Jurka | a8352d2 | 2012-02-23 16:28:37 -0800 | [diff] [blame] | 386 | // Stop the scrolling indicator - we don't want All Apps to be invalidating itself |
| 387 | // during the transition, especially since it has a hardware layer set on it |
| 388 | mAppsCustomizePane.cancelScrollingIndicatorAnimations(); |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 389 | } else { |
| 390 | // Going from Workspace -> All Apps |
| 391 | mContent.setVisibility(VISIBLE); |
Michael Jurka | 3d845e8 | 2011-11-15 17:04:31 -0800 | [diff] [blame] | 392 | |
Michael Jurka | e326f18 | 2011-11-21 14:05:46 -0800 | [diff] [blame] | 393 | // Make sure the current page is loaded (we start loading the side pages after the |
| 394 | // transition to prevent slowing down the animation) |
| 395 | mAppsCustomizePane.loadAssociatedPages(mAppsCustomizePane.getCurrentPage(), true); |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 396 | |
| 397 | if (!LauncherApplication.isScreenLarge()) { |
| 398 | mAppsCustomizePane.showScrollingIndicator(true); |
| 399 | } |
Michael Jurka | 1899a36 | 2011-11-03 13:50:45 -0700 | [diff] [blame] | 400 | } |
| 401 | |
Winson Chung | c100e8e | 2011-08-09 16:02:43 -0700 | [diff] [blame] | 402 | if (mResetAfterTransition) { |
| 403 | mAppsCustomizePane.reset(); |
| 404 | mResetAfterTransition = false; |
| 405 | } |
Michael Jurka | a35e35a | 2012-04-26 15:04:28 -0700 | [diff] [blame] | 406 | } |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 407 | |
Michael Jurka | a35e35a | 2012-04-26 15:04:28 -0700 | [diff] [blame] | 408 | @Override |
| 409 | public void onLauncherTransitionStart(Launcher l, boolean animated, boolean toWorkspace) { |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 410 | if (animated) { |
| 411 | enableAndBuildHardwareLayer(); |
| 412 | } |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 413 | } |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 414 | |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 415 | @Override |
Winson Chung | 7044272 | 2012-02-10 15:43:22 -0800 | [diff] [blame] | 416 | public void onLauncherTransitionStep(Launcher l, float t) { |
| 417 | // Do nothing |
| 418 | } |
| 419 | |
| 420 | @Override |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 421 | public void onLauncherTransitionEnd(Launcher l, boolean animated, boolean toWorkspace) { |
Michael Jurka | 39e5d17 | 2012-03-12 18:36:12 -0700 | [diff] [blame] | 422 | mAppsCustomizePane.onLauncherTransitionEnd(l, animated, toWorkspace); |
Winson Chung | c100e8e | 2011-08-09 16:02:43 -0700 | [diff] [blame] | 423 | mInTransition = false; |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 424 | if (animated) { |
Winson Chung | f0ea4d3 | 2011-06-06 14:27:16 -0700 | [diff] [blame] | 425 | setLayerType(LAYER_TYPE_NONE, null); |
| 426 | } |
Winson Chung | 3ac74c5 | 2011-06-30 17:39:37 -0700 | [diff] [blame] | 427 | |
Winson Chung | 7d7541e | 2011-09-16 20:14:36 -0700 | [diff] [blame] | 428 | if (!toWorkspace) { |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 429 | // Going from Workspace -> All Apps |
| 430 | setVisibilityOfSiblingsWithLowerZOrder(INVISIBLE); |
| 431 | |
Winson Chung | 3f4e142 | 2011-11-17 14:58:51 -0800 | [diff] [blame] | 432 | // Dismiss the workspace cling and show the all apps cling (if not already shown) |
Winson Chung | 7d7541e | 2011-09-16 20:14:36 -0700 | [diff] [blame] | 433 | l.dismissWorkspaceCling(null); |
Winson Chung | 3f4e142 | 2011-11-17 14:58:51 -0800 | [diff] [blame] | 434 | mAppsCustomizePane.showAllAppsCling(); |
Michael Jurka | e326f18 | 2011-11-21 14:05:46 -0800 | [diff] [blame] | 435 | // Make sure adjacent pages are loaded (we wait until after the transition to |
| 436 | // prevent slowing down the animation) |
| 437 | mAppsCustomizePane.loadAssociatedPages(mAppsCustomizePane.getCurrentPage()); |
Winson Chung | 7d7541e | 2011-09-16 20:14:36 -0700 | [diff] [blame] | 438 | |
| 439 | if (!LauncherApplication.isScreenLarge()) { |
| 440 | mAppsCustomizePane.hideScrollingIndicator(false); |
| 441 | } |
Winson Chung | 5a80835 | 2011-06-27 19:08:49 -0700 | [diff] [blame] | 442 | } |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 443 | } |
Winson Chung | 70d7210 | 2011-08-12 11:24:35 -0700 | [diff] [blame] | 444 | |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 445 | private void setVisibilityOfSiblingsWithLowerZOrder(int visibility) { |
| 446 | ViewGroup parent = (ViewGroup) getParent(); |
Michael Jurka | aea1ce5 | 2012-04-12 11:23:21 -0700 | [diff] [blame] | 447 | if (parent == null) return; |
| 448 | |
Michael Jurka | bed61d2 | 2012-02-14 22:51:29 -0800 | [diff] [blame] | 449 | final int count = parent.getChildCount(); |
| 450 | if (!isChildrenDrawingOrderEnabled()) { |
| 451 | for (int i = 0; i < count; i++) { |
| 452 | final View child = parent.getChildAt(i); |
| 453 | if (child == this) { |
| 454 | break; |
| 455 | } else { |
| 456 | if (child.getVisibility() == GONE) { |
| 457 | continue; |
| 458 | } |
| 459 | child.setVisibility(visibility); |
| 460 | } |
| 461 | } |
| 462 | } else { |
| 463 | throw new RuntimeException("Failed; can't get z-order of views"); |
| 464 | } |
| 465 | } |
| 466 | |
Michael Jurka | 2a4b1a8 | 2011-12-07 14:00:02 -0800 | [diff] [blame] | 467 | public void onWindowVisible() { |
Michael Jurka | e326f18 | 2011-11-21 14:05:46 -0800 | [diff] [blame] | 468 | if (getVisibility() == VISIBLE) { |
| 469 | mContent.setVisibility(VISIBLE); |
| 470 | // We unload the widget previews when the UI is hidden, so need to reload pages |
| 471 | // Load the current page synchronously, and the neighboring pages asynchronously |
| 472 | mAppsCustomizePane.loadAssociatedPages(mAppsCustomizePane.getCurrentPage(), true); |
| 473 | mAppsCustomizePane.loadAssociatedPages(mAppsCustomizePane.getCurrentPage()); |
| 474 | } |
| 475 | } |
| 476 | |
| 477 | public void onTrimMemory() { |
| 478 | mContent.setVisibility(GONE); |
| 479 | // Clear the widget pages of all their subviews - this will trigger the widget previews |
| 480 | // to delete their bitmaps |
| 481 | mAppsCustomizePane.clearAllWidgetPages(); |
| 482 | } |
| 483 | |
Winson Chung | 70d7210 | 2011-08-12 11:24:35 -0700 | [diff] [blame] | 484 | boolean isTransitioning() { |
| 485 | return mInTransition; |
| 486 | } |
Winson Chung | 785d2eb | 2011-04-14 16:08:02 -0700 | [diff] [blame] | 487 | } |