v7/appcompat/src/android/support/v7/app/ActionBarActivityDelegateHC.java - platform/frameworks/support - Git at Google

 /*
  * 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 android.support.v7.app;

 import android.content.Context;
 import android.content.res.Configuration;
 import android.os.Bundle;
 import android.support.v4.app.ActionBarDrawerToggle;
 import android.support.v4.view.WindowCompat;
 import android.support.v7.internal.view.ActionModeWrapper;
 import android.support.v7.internal.view.menu.MenuWrapperFactory;
 import android.support.v7.view.ActionMode;
 import android.view.KeyEvent;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.Window;
 import android.view.WindowManager;
 import android.view.accessibility.AccessibilityEvent;

 class ActionBarActivityDelegateHC extends ActionBarActivityDelegate {
     Menu mMenu;

     ActionBarActivityDelegateHC(ActionBarActivity activity) {
         super(activity);
     }

     @Override
     public ActionBar createSupportActionBar() {
         return new ActionBarImplHC(mActivity, mActivity);
     }

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         if (mHasActionBar) {
             // If action bar is requested by inheriting from the appcompat theme,
             // the system will not know about that. So explicitly request for an action bar.
             mActivity.requestWindowFeature(WindowCompat.FEATURE_ACTION_BAR);
         }
         if (mOverlayActionBar) {
             mActivity.requestWindowFeature(WindowCompat.FEATURE_ACTION_BAR_OVERLAY);
         }

         /*
          * This goofy move needs some explanation.
          *
          * The verifier on older platform versions has some interesting side effects if
          * a class defines a method that takes a parameter of a type that doesn't exist.
          * In this case, that type is android.view.ActionMode. Therefore, ActionBarActivity
          * cannot override the onActionModeStarted/Finished methods without causing nastiness
          * when it is loaded on older platform versions.
          *
          * Since these methods are actually part of the window callback and not intrinsic to
          * Activity itself, we can install a little shim with the window instead that knows
          * about the ActionMode class. Note that this means that any new methods added to
          * Window.Callback in the future won't get proxied without updating the support lib,
          * but we shouldn't be adding new methods to public interfaces that way anyway...right? ;)
          */
         final Window w = mActivity.getWindow();
         w.setCallback(createWindowCallbackWrapper(w.getCallback()));
     }

     Window.Callback createWindowCallbackWrapper(Window.Callback cb) {
         return new WindowCallbackWrapper(cb);
     }

     @Override
     public void onConfigurationChanged(Configuration newConfig) {
     }

     @Override
     public void onStop() {
     }

     @Override
     public void onPostResume() {
     }

     @Override
     public void setContentView(View v) {
         mActivity.superSetContentView(v);
     }

     @Override
     public void setContentView(int resId) {
         mActivity.superSetContentView(resId);
     }

     @Override
     public void setContentView(View v, ViewGroup.LayoutParams lp) {
         mActivity.superSetContentView(v, lp);
     }

     @Override
     public void addContentView(View v, ViewGroup.LayoutParams lp) {
         mActivity.superAddContentView(v, lp);
     }

     @Override
     public boolean supportRequestWindowFeature(int featureId) {
         return mActivity.requestWindowFeature(featureId);
     }

     @Override
     public View onCreatePanelView(int featureId) {
         // Do not create custom options menu on HC+
         return null;
     }

     @Override
     public boolean onCreatePanelMenu(int featureId, Menu menu) {
         if (featureId == Window.FEATURE_OPTIONS_PANEL || featureId == Window.FEATURE_ACTION_BAR) {
             if (mMenu == null) {
                 mMenu = MenuWrapperFactory.createMenuWrapper(menu);
             }
             return mActivity.superOnCreatePanelMenu(featureId, mMenu);
         }
         return mActivity.superOnCreatePanelMenu(featureId, menu);
     }

     @Override
     public boolean onPreparePanel(int featureId, View view, Menu menu) {
         if (featureId == Window.FEATURE_OPTIONS_PANEL || featureId == Window.FEATURE_ACTION_BAR) {
             return mActivity.superOnPreparePanel(featureId, view, mMenu);
         }
         return mActivity.superOnPreparePanel(featureId, view, menu);
     }

     @Override
     public boolean onMenuItemSelected(int featureId, MenuItem item) {
         if (featureId == Window.FEATURE_OPTIONS_PANEL) {
             item = MenuWrapperFactory.createMenuItemWrapper(item);
         }
         return mActivity.superOnMenuItemSelected(featureId, item);
     }

     @Override
     public void setTitle(CharSequence title) {
         // Handled by framework
     }

     @Override
     public ActionMode startSupportActionMode(ActionMode.Callback callback) {
         if (callback == null) {
             throw new IllegalArgumentException("ActionMode callback can not be null.");
         }

         Context context = getActionBarThemedContext();

         ActionModeWrapper.CallbackWrapper wrappedCallback = new ActionModeWrapper.CallbackWrapper(
                 context, callback);
         ActionModeWrapper wrappedMode = null;

         android.view.ActionMode frameworkMode = mActivity.startActionMode(wrappedCallback);

         if (frameworkMode != null) {
             wrappedMode = new ActionModeWrapper(context,
                     mActivity.startActionMode(wrappedCallback));
             wrappedCallback.setLastStartedActionMode(wrappedMode);
         }

         return wrappedMode;
     }

     public void onActionModeStarted(android.view.ActionMode mode) {
         mActivity.onSupportActionModeStarted(
                 new ActionModeWrapper(getActionBarThemedContext(), mode));
     }

     @Override
     void setSupportProgressBarVisibility(boolean visible) {
         mActivity.setProgressBarVisibility(visible);
     }

     @Override
     void setSupportProgressBarIndeterminateVisibility(boolean visible) {
         mActivity.setProgressBarIndeterminateVisibility(visible);
     }

     @Override
     void setSupportProgressBarIndeterminate(boolean indeterminate) {
         mActivity.setProgressBarIndeterminate(indeterminate);
     }

     @Override
     void setSupportProgress(int progress) {
         mActivity.setProgress(progress);
     }

     public void onActionModeFinished(android.view.ActionMode mode) {
         mActivity.onSupportActionModeFinished(
                 new ActionModeWrapper(getActionBarThemedContext(), mode));
     }

     @Override
     public void supportInvalidateOptionsMenu() {
         mMenu = null;
     }

     @Override
     public boolean onBackPressed() {
         return false;
     }

     @Override
     public ActionBarDrawerToggle.Delegate getDrawerToggleDelegate() {
         // Return null so that ActionBarDrawableToggle uses it's standard impl
         return null;
     }

     class WindowCallbackWrapper implements Window.Callback {
         final Window.Callback mWrapped;

         public WindowCallbackWrapper(Window.Callback wrapped) {
             mWrapped = wrapped;
         }

         @Override
         public boolean dispatchKeyEvent(KeyEvent event) {
             return mWrapped.dispatchKeyEvent(event);
         }

         @Override
         public boolean dispatchKeyShortcutEvent(KeyEvent event) {
             return mWrapped.dispatchKeyShortcutEvent(event);
         }

         @Override
         public boolean dispatchTouchEvent(MotionEvent event) {
             return mWrapped.dispatchTouchEvent(event);
         }

         @Override
         public boolean dispatchTrackballEvent(MotionEvent event) {
             return mWrapped.dispatchTrackballEvent(event);
         }

         public boolean dispatchGenericMotionEvent(MotionEvent event) {
             // This method didn't exist until API 12. Overridden elsewhere.
             return false;
         }

         @Override
         public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
             return mWrapped.dispatchPopulateAccessibilityEvent(event);
         }

         @Override
         public View onCreatePanelView(int featureId) {
             return mWrapped.onCreatePanelView(featureId);
         }

         @Override
         public boolean onCreatePanelMenu(int featureId, Menu menu) {
             return mWrapped.onCreatePanelMenu(featureId, menu);
         }

         @Override
         public boolean onPreparePanel(int featureId, View view, Menu menu) {
             return mWrapped.onPreparePanel(featureId, view, menu);
         }

         @Override
         public boolean onMenuOpened(int featureId, Menu menu) {
             return mWrapped.onMenuOpened(featureId, menu);
         }

         @Override
         public boolean onMenuItemSelected(int featureId, MenuItem item) {
             return mWrapped.onMenuItemSelected(featureId, item);
         }

         @Override
         public void onWindowAttributesChanged(WindowManager.LayoutParams attrs) {
             mWrapped.onWindowAttributesChanged(attrs);
         }

         @Override
         public void onContentChanged() {
             mWrapped.onContentChanged();
         }

         @Override
         public void onWindowFocusChanged(boolean hasFocus) {
             mWrapped.onWindowFocusChanged(hasFocus);
         }

         @Override
         public void onAttachedToWindow() {
             mWrapped.onAttachedToWindow();
         }

         @Override
         public void onDetachedFromWindow() {
             mWrapped.onDetachedFromWindow();
         }

         @Override
         public void onPanelClosed(int featureId, Menu menu) {
             mWrapped.onPanelClosed(featureId, menu);
         }

         @Override
         public boolean onSearchRequested() {
             return mWrapped.onSearchRequested();
         }

         @Override
         public android.view.ActionMode onWindowStartingActionMode(
                 android.view.ActionMode.Callback callback) {
             return mWrapped.onWindowStartingActionMode(callback);
         }

         /*
          * And here are the money methods, the reason why this wrapper exists:
          */

         @Override
         public void onActionModeStarted(android.view.ActionMode mode) {
             mWrapped.onActionModeStarted(mode);
             ActionBarActivityDelegateHC.this.onActionModeStarted(mode);
         }

         @Override
         public void onActionModeFinished(android.view.ActionMode mode) {
             mWrapped.onActionModeFinished(mode);
             ActionBarActivityDelegateHC.this.onActionModeFinished(mode);
         }
     }
 }
	/*
	* 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 android.support.v7.app;

	import android.content.Context;
	import android.content.res.Configuration;
	import android.os.Bundle;
	import android.support.v4.app.ActionBarDrawerToggle;
	import android.support.v4.view.WindowCompat;
	import android.support.v7.internal.view.ActionModeWrapper;
	import android.support.v7.internal.view.menu.MenuWrapperFactory;
	import android.support.v7.view.ActionMode;
	import android.view.KeyEvent;
	import android.view.Menu;
	import android.view.MenuItem;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.Window;
	import android.view.WindowManager;
	import android.view.accessibility.AccessibilityEvent;

	class ActionBarActivityDelegateHC extends ActionBarActivityDelegate {
	Menu mMenu;

	ActionBarActivityDelegateHC(ActionBarActivity activity) {
	super(activity);
	}

	@Override
	public ActionBar createSupportActionBar() {
	return new ActionBarImplHC(mActivity, mActivity);
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	if (mHasActionBar) {
	// If action bar is requested by inheriting from the appcompat theme,
	// the system will not know about that. So explicitly request for an action bar.
	mActivity.requestWindowFeature(WindowCompat.FEATURE_ACTION_BAR);
	}
	if (mOverlayActionBar) {
	mActivity.requestWindowFeature(WindowCompat.FEATURE_ACTION_BAR_OVERLAY);
	}

	/*
	* This goofy move needs some explanation.
	*
	* The verifier on older platform versions has some interesting side effects if
	* a class defines a method that takes a parameter of a type that doesn't exist.
	* In this case, that type is android.view.ActionMode. Therefore, ActionBarActivity
	* cannot override the onActionModeStarted/Finished methods without causing nastiness
	* when it is loaded on older platform versions.
	*
	* Since these methods are actually part of the window callback and not intrinsic to
	* Activity itself, we can install a little shim with the window instead that knows
	* about the ActionMode class. Note that this means that any new methods added to
	* Window.Callback in the future won't get proxied without updating the support lib,
	* but we shouldn't be adding new methods to public interfaces that way anyway...right? ;)
	*/
	final Window w = mActivity.getWindow();
	w.setCallback(createWindowCallbackWrapper(w.getCallback()));
	}

	Window.Callback createWindowCallbackWrapper(Window.Callback cb) {
	return new WindowCallbackWrapper(cb);
	}

	@Override
	public void onConfigurationChanged(Configuration newConfig) {
	}

	@Override
	public void onStop() {
	}

	@Override
	public void onPostResume() {
	}

	@Override
	public void setContentView(View v) {
	mActivity.superSetContentView(v);
	}

	@Override
	public void setContentView(int resId) {
	mActivity.superSetContentView(resId);
	}

	@Override
	public void setContentView(View v, ViewGroup.LayoutParams lp) {
	mActivity.superSetContentView(v, lp);
	}

	@Override
	public void addContentView(View v, ViewGroup.LayoutParams lp) {
	mActivity.superAddContentView(v, lp);
	}

	@Override
	public boolean supportRequestWindowFeature(int featureId) {
	return mActivity.requestWindowFeature(featureId);
	}

	@Override
	public View onCreatePanelView(int featureId) {
	// Do not create custom options menu on HC+
	return null;
	}

	@Override
	public boolean onCreatePanelMenu(int featureId, Menu menu) {
	if (featureId == Window.FEATURE_OPTIONS_PANEL \|\| featureId == Window.FEATURE_ACTION_BAR) {
	if (mMenu == null) {
	mMenu = MenuWrapperFactory.createMenuWrapper(menu);
	}
	return mActivity.superOnCreatePanelMenu(featureId, mMenu);
	}
	return mActivity.superOnCreatePanelMenu(featureId, menu);
	}

	@Override
	public boolean onPreparePanel(int featureId, View view, Menu menu) {
	if (featureId == Window.FEATURE_OPTIONS_PANEL \|\| featureId == Window.FEATURE_ACTION_BAR) {
	return mActivity.superOnPreparePanel(featureId, view, mMenu);
	}
	return mActivity.superOnPreparePanel(featureId, view, menu);
	}

	@Override
	public boolean onMenuItemSelected(int featureId, MenuItem item) {
	if (featureId == Window.FEATURE_OPTIONS_PANEL) {
	item = MenuWrapperFactory.createMenuItemWrapper(item);
	}
	return mActivity.superOnMenuItemSelected(featureId, item);
	}

	@Override
	public void setTitle(CharSequence title) {
	// Handled by framework
	}

	@Override
	public ActionMode startSupportActionMode(ActionMode.Callback callback) {
	if (callback == null) {
	throw new IllegalArgumentException("ActionMode callback can not be null.");
	}

	Context context = getActionBarThemedContext();

	ActionModeWrapper.CallbackWrapper wrappedCallback = new ActionModeWrapper.CallbackWrapper(
	context, callback);
	ActionModeWrapper wrappedMode = null;

	android.view.ActionMode frameworkMode = mActivity.startActionMode(wrappedCallback);

	if (frameworkMode != null) {
	wrappedMode = new ActionModeWrapper(context,
	mActivity.startActionMode(wrappedCallback));
	wrappedCallback.setLastStartedActionMode(wrappedMode);
	}

	return wrappedMode;
	}

	public void onActionModeStarted(android.view.ActionMode mode) {
	mActivity.onSupportActionModeStarted(
	new ActionModeWrapper(getActionBarThemedContext(), mode));
	}

	@Override
	void setSupportProgressBarVisibility(boolean visible) {
	mActivity.setProgressBarVisibility(visible);
	}

	@Override
	void setSupportProgressBarIndeterminateVisibility(boolean visible) {
	mActivity.setProgressBarIndeterminateVisibility(visible);
	}

	@Override
	void setSupportProgressBarIndeterminate(boolean indeterminate) {
	mActivity.setProgressBarIndeterminate(indeterminate);
	}

	@Override
	void setSupportProgress(int progress) {
	mActivity.setProgress(progress);
	}

	public void onActionModeFinished(android.view.ActionMode mode) {
	mActivity.onSupportActionModeFinished(
	new ActionModeWrapper(getActionBarThemedContext(), mode));
	}

	@Override
	public void supportInvalidateOptionsMenu() {
	mMenu = null;
	}

	@Override
	public boolean onBackPressed() {
	return false;
	}

	@Override
	public ActionBarDrawerToggle.Delegate getDrawerToggleDelegate() {
	// Return null so that ActionBarDrawableToggle uses it's standard impl
	return null;
	}

	class WindowCallbackWrapper implements Window.Callback {
	final Window.Callback mWrapped;

	public WindowCallbackWrapper(Window.Callback wrapped) {
	mWrapped = wrapped;
	}

	@Override
	public boolean dispatchKeyEvent(KeyEvent event) {
	return mWrapped.dispatchKeyEvent(event);
	}

	@Override
	public boolean dispatchKeyShortcutEvent(KeyEvent event) {
	return mWrapped.dispatchKeyShortcutEvent(event);
	}

	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
	return mWrapped.dispatchTouchEvent(event);
	}

	@Override
	public boolean dispatchTrackballEvent(MotionEvent event) {
	return mWrapped.dispatchTrackballEvent(event);
	}

	public boolean dispatchGenericMotionEvent(MotionEvent event) {
	// This method didn't exist until API 12. Overridden elsewhere.
	return false;
	}

	@Override
	public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
	return mWrapped.dispatchPopulateAccessibilityEvent(event);
	}

	@Override
	public View onCreatePanelView(int featureId) {
	return mWrapped.onCreatePanelView(featureId);
	}

	@Override
	public boolean onCreatePanelMenu(int featureId, Menu menu) {
	return mWrapped.onCreatePanelMenu(featureId, menu);
	}

	@Override
	public boolean onPreparePanel(int featureId, View view, Menu menu) {
	return mWrapped.onPreparePanel(featureId, view, menu);
	}

	@Override
	public boolean onMenuOpened(int featureId, Menu menu) {
	return mWrapped.onMenuOpened(featureId, menu);
	}

	@Override
	public boolean onMenuItemSelected(int featureId, MenuItem item) {
	return mWrapped.onMenuItemSelected(featureId, item);
	}

	@Override
	public void onWindowAttributesChanged(WindowManager.LayoutParams attrs) {
	mWrapped.onWindowAttributesChanged(attrs);
	}

	@Override
	public void onContentChanged() {
	mWrapped.onContentChanged();
	}

	@Override
	public void onWindowFocusChanged(boolean hasFocus) {
	mWrapped.onWindowFocusChanged(hasFocus);
	}

	@Override
	public void onAttachedToWindow() {
	mWrapped.onAttachedToWindow();
	}

	@Override
	public void onDetachedFromWindow() {
	mWrapped.onDetachedFromWindow();
	}

	@Override
	public void onPanelClosed(int featureId, Menu menu) {
	mWrapped.onPanelClosed(featureId, menu);
	}

	@Override
	public boolean onSearchRequested() {
	return mWrapped.onSearchRequested();
	}

	@Override
	public android.view.ActionMode onWindowStartingActionMode(
	android.view.ActionMode.Callback callback) {
	return mWrapped.onWindowStartingActionMode(callback);
	}

	/*
	* And here are the money methods, the reason why this wrapper exists:
	*/

	@Override
	public void onActionModeStarted(android.view.ActionMode mode) {
	mWrapped.onActionModeStarted(mode);
	ActionBarActivityDelegateHC.this.onActionModeStarted(mode);
	}

	@Override
	public void onActionModeFinished(android.view.ActionMode mode) {
	mWrapped.onActionModeFinished(mode);
	ActionBarActivityDelegateHC.this.onActionModeFinished(mode);
	}
	}
	}