示例#1
0
 /** 改变private/protected的方法为public,尽量不调用实际改动的语句,避免JDK的SecurityManager抱怨。 */
 public static void makeAccessible(Method method) {
   if ((!Modifier.isPublic(method.getModifiers())
           || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
       && !method.isAccessible()) {
     method.setAccessible(true);
   }
 }
 protected Serializable fieldValue(final Object obj, final AnnotatedElement annotatedElement) {
   if (annotatedElement instanceof Field) { // a field
     final Field f = (Field) annotatedElement;
     if (!f.isAccessible()) {
       f.setAccessible(true);
     }
     try {
       return (Serializable) f.get(obj);
     } catch (final IllegalArgumentException e) {
       logger.warn("获取" + obj.getClass().getName() + "的id字段" + f.getName() + "的值失败。", e);
     } catch (final IllegalAccessException e) {
       logger.warn("获取" + obj.getClass().getName() + "的id字段" + f.getName() + "的值失败。", e);
     } catch (final ClassCastException e) {
       logger.warn(obj.getClass().getName() + "的id字段" + f.getName() + "不可序列化。", e);
     }
   } else { // a method
     final Method m = (Method) annotatedElement;
     if (!m.isAccessible()) {
       m.setAccessible(true);
     }
     try {
       return (Serializable) ReflectionUtils.invokeMethod(m, obj);
     } catch (final ClassCastException e) {
       logger.warn(obj.getClass().getName() + "的id字段" + m.getName() + "不可序列化。", e);
     }
   }
   return null;
 }
 public Object doGetValue() {
   try {
     Method readMethod = propertyDescriptor.getReadMethod();
     if (readMethod == null) {
       throw new BindingException(
           propertyDescriptor.getName() + " property does not have a read method."); // $NON-NLS-1$
     }
     if (!readMethod.isAccessible()) {
       readMethod.setAccessible(true);
     }
     return readMethod.invoke(object, null);
   } catch (InvocationTargetException e) {
     /*
      * InvocationTargetException wraps any exception thrown by the
      * invoked method.
      */
     throw new RuntimeException(e.getCause());
   } catch (Exception e) {
     if (BeansObservables.DEBUG) {
       Policy.getLog()
           .log(
               new Status(
                   IStatus.WARNING,
                   Policy.JFACE_DATABINDING,
                   IStatus.OK,
                   "Could not read value of " + object + "." + propertyDescriptor.getName(),
                   e)); //$NON-NLS-1$ //$NON-NLS-2$
     }
     return null;
   }
 }
 public void doSetValue(Object value) {
   updating = true;
   try {
     Object oldValue = doGetValue();
     Method writeMethod = propertyDescriptor.getWriteMethod();
     if (!writeMethod.isAccessible()) {
       writeMethod.setAccessible(true);
     }
     writeMethod.invoke(object, new Object[] {value});
     fireValueChange(Diffs.createValueDiff(oldValue, doGetValue()));
   } catch (InvocationTargetException e) {
     /*
      * InvocationTargetException wraps any exception thrown by the
      * invoked method.
      */
     throw new RuntimeException(e.getCause());
   } catch (Exception e) {
     if (BeansObservables.DEBUG) {
       Policy.getLog()
           .log(
               new Status(
                   IStatus.WARNING,
                   Policy.JFACE_DATABINDING,
                   IStatus.OK,
                   "Could not change value of " + object + "." + propertyDescriptor.getName(),
                   e)); //$NON-NLS-1$ //$NON-NLS-2$
     }
   } finally {
     updating = false;
   }
 }
示例#5
0
 public void setApplicationContext(ApplicationContext applicationContext) {
   this.applicationContext = applicationContext;
   SpringExtensionFactory.addApplicationContext(applicationContext);
   if (applicationContext != null) {
     SPRING_CONTEXT = applicationContext;
     try {
       Method method =
           applicationContext
               .getClass()
               .getMethod(
                   "addApplicationListener",
                   new Class<?>[] {ApplicationListener.class}); // 兼容Spring2.0.1
       method.invoke(applicationContext, new Object[] {this});
       supportedApplicationListener = true;
     } catch (Throwable t) {
       if (applicationContext instanceof AbstractApplicationContext) {
         try {
           Method method =
               AbstractApplicationContext.class.getDeclaredMethod(
                   "addListener", new Class<?>[] {ApplicationListener.class}); // 兼容Spring2.0.1
           if (!method.isAccessible()) {
             method.setAccessible(true);
           }
           method.invoke(applicationContext, new Object[] {this});
           supportedApplicationListener = true;
         } catch (Throwable t2) {
         }
       }
     }
   }
 }
 private JarURLConnection openJarURLConnection(final URL url) throws IOException {
   final URL checkedUrl;
   if ("zip".equals(url.getProtocol())) {
     // WebLogic returns URL with "zip" protocol, returning a
     // weblogic.utils.zip.ZipURLConnection when opened
     // Easy fix is to convert this URL to jar URL
     checkedUrl = new URL(url.toExternalForm().replace("zip:/", "jar:file:/"));
   } else {
     checkedUrl = url;
   }
   URLConnection urlConnection = checkedUrl.openConnection();
   // GlassFish 4.1.1 is providing a URLConnection of type:
   // http://svn.apache.org/viewvc/felix/trunk/framework/src/main/java/org/
   // apache/felix/framework/URLHandlersBundleURLConnection.java?view=markup
   // Which does _not_ extend JarURLConnection.
   // This bit of reflection allows us to call the getLocalURL method which
   // actually returns a URL to a jar file.
   if (checkedUrl.getProtocol().startsWith("bundle")) {
     try {
       final Method m = urlConnection.getClass().getDeclaredMethod("getLocalURL");
       if (!m.isAccessible()) {
         m.setAccessible(true);
       }
       final URL jarUrl = (URL) m.invoke(urlConnection);
       urlConnection = jarUrl.openConnection();
     } catch (Exception ex) {
       throw new AssertionError("Couldn't read jar file URL from bundle: " + ex);
     }
   }
   if (urlConnection instanceof JarURLConnection) {
     return (JarURLConnection) urlConnection;
   } else {
     throw new AssertionError("Unknown URLConnection type: " + urlConnection.getClass().getName());
   }
 }
 @Override
 public Object invokeImpl(Object proxy, Method method, Object[] args) throws SentryUserException {
   Object result = null;
   try {
     if (!method.isAccessible()) {
       method.setAccessible(true);
     }
     // The client is initialized in the first call instead of constructor.
     // This way we can propagate the connection exception to caller cleanly
     if (client == null) {
       renewSentryClient();
     }
     result = method.invoke(client, args);
   } catch (IllegalAccessException e) {
     throw new SentryUserException(e.getMessage(), e.getCause());
   } catch (InvocationTargetException e) {
     if (e.getTargetException() instanceof SentryUserException) {
       throw (SentryUserException) e.getTargetException();
     } else {
       LOGGER.warn(
           THRIFT_EXCEPTION_MESSAGE
               + ": Error in connect current"
               + " service, will retry other service.",
           e);
       if (client != null) {
         client.close();
         client = null;
       }
     }
   } catch (IOException e1) {
     throw new SentryUserException("Error connecting to sentry service " + e1.getMessage(), e1);
   }
   return result;
 }
示例#8
0
  /**
   * Invoke the method on the instance, with any arguments specified, casting the result of invoking
   * the method to the expected return type.
   *
   * <p>
   *
   * <p>This method wraps {@link Method#invoke(Object, Object...)}, converting the checked
   * exceptions that {@link Method#invoke(Object, Object...)} specifies to runtime exceptions.
   *
   * <p>
   *
   * <p>If instructed, this method attempts to set the accessible flag of the method in a {@link
   * PrivilegedAction} before invoking the method.
   *
   * @param setAccessible flag indicating whether method should first be set as accessible
   * @param method the method to invoke
   * @param instance the instance to invoke the method
   * @param args the arguments to the method
   * @return the result of invoking the method, or null if the method's return type is void
   * @throws RuntimeException if this <code>Method</code> object enforces Java language access
   *     control and the underlying method is inaccessible or if the underlying method throws an
   *     exception or if the initialization provoked by this method fails.
   * @throws IllegalArgumentException if the method is an instance method and the specified <code>
   *     instance</code> argument is not an instance of the class or interface declaring the
   *     underlying method (or of a subclass or implementor thereof); if the number of actual and
   *     formal parameters differ; if an unwrapping conversion for primitive arguments fails; or if,
   *     after possible unwrapping, a parameter value cannot be converted to the corresponding
   *     formal parameter type by a method invocation conversion.
   * @throws NullPointerException if the specified <code>instance</code> is null and the method is
   *     an instance method.
   * @throws ClassCastException if the result of invoking the method cannot be cast to the
   *     expectedReturnType
   * @throws ExceptionInInitializerError if the initialization provoked by this method fails.
   * @see Method#invoke(Object, Object...)
   */
  public static <T> T invokeMethod(
      boolean setAccessible,
      Method method,
      Class<T> expectedReturnType,
      Object instance,
      Object... args) {
    if (setAccessible && !method.isAccessible()) {
      setAccessible(method);
    }

    try {
      return expectedReturnType.cast(method.invoke(instance, args));
    } catch (IllegalAccessException ex) {
      throw new RuntimeException(buildInvokeMethodErrorMessage(method, instance, args), ex);
    } catch (IllegalArgumentException ex) {
      throw new IllegalArgumentException(buildInvokeMethodErrorMessage(method, instance, args), ex);
    } catch (InvocationTargetException ex) {
      throw new RuntimeException(
          buildInvokeMethodErrorMessage(method, instance, args), ex.getCause());
    } catch (NullPointerException ex) {
      NullPointerException ex2 =
          new NullPointerException(buildInvokeMethodErrorMessage(method, instance, args));
      ex2.initCause(ex.getCause());
      throw ex2;
    } catch (ExceptionInInitializerError e) {
      ExceptionInInitializerError e2 =
          new ExceptionInInitializerError(buildInvokeMethodErrorMessage(method, instance, args));
      e2.initCause(e.getCause());
      throw e2;
    }
  }
  /**
   * Call preDestroy method on the specified instance recursively from deepest superclass to actual
   * class.
   *
   * @param instance object to call preDestroy methods on
   * @param clazz (super) class to examine for preDestroy annotation.
   * @throws IllegalAccessException if preDestroy method is inaccessible.
   * @throws java.lang.reflect.InvocationTargetException if call fails
   */
  protected void preDestroy(Object instance, final Class<?> clazz)
      throws IllegalAccessException, InvocationTargetException {
    Class<?> superClass = clazz.getSuperclass();
    if (superClass != Object.class) {
      preDestroy(instance, superClass);
    }

    // At the end the postconstruct annotated
    // method is invoked
    List<AnnotationCacheEntry> annotations = null;
    synchronized (annotationCache) {
      annotations = annotationCache.get(clazz);
    }
    if (annotations == null) {
      // instance not created through the instance manager
      return;
    }
    for (AnnotationCacheEntry entry : annotations) {
      if (entry.getType() == AnnotationCacheEntryType.PRE_DESTROY) {
        Method preDestroy = getMethod(clazz, entry);
        synchronized (preDestroy) {
          boolean accessibility = preDestroy.isAccessible();
          preDestroy.setAccessible(true);
          preDestroy.invoke(instance);
          preDestroy.setAccessible(accessibility);
        }
      }
    }
  }
 @Override
 public TypedValue read(EvaluationContext context, Object target, String name)
     throws AccessException {
   if (this.member instanceof Method) {
     Method method = (Method) this.member;
     try {
       if (this.needsToBeMadeAccessible && !method.isAccessible()) {
         method.setAccessible(true);
       }
       Object value = method.invoke(target);
       return new TypedValue(value, this.typeDescriptor.narrow(value));
     } catch (Exception ex) {
       throw new AccessException(
           "Unable to access property '" + name + "' through getter method", ex);
     }
   } else {
     Field field = (Field) this.member;
     try {
       if (this.needsToBeMadeAccessible && !field.isAccessible()) {
         field.setAccessible(true);
       }
       Object value = field.get(target);
       return new TypedValue(value, this.typeDescriptor.narrow(value));
     } catch (Exception ex) {
       throw new AccessException("Unable to access field '" + name + "'", ex);
     }
   }
 }
 /**
  * Constructs a new RegisteredEventListener surrounding the given {@code listenerMethod} of the
  * provided {@code listener} object.
  *
  * @param listenerMethod The event handler method to be wrapped by this RegisteredEventListener.
  * @param listener The object on which {@code method} is to be called.
  * @throws IllegalArgumentException If {@code listenerMethod} does not have an EventListener
  *     annotation or if {@code listenerMthod} does not accept a single {@link Event} subclass
  *     object as a parameter.
  */
 public RegisteredEventListener(Method listenerMethod, Listener listener) {
   // Attempt to get the EventListener annotation on this method
   EventListener listenerAnnotation = listenerMethod.getAnnotation(EventListener.class);
   if (listenerAnnotation == null) {
     // No annotation, throw exception
     throw new IllegalArgumentException(
         "Listener method does not have an EventListener annotation.");
   }
   // Get priority and ignoreCancelled values from the annotation
   priority = listenerAnnotation.priority();
   ignoresCancelled = listenerAnnotation.ignoreCancelled();
   // Get the parameter types of the method
   Class<?>[] listenerMethodParameters = listenerMethod.getParameterTypes();
   // Verify that the parameters of the method are valid for an event-handling method
   if (listenerMethodParameters.length != 1
       || !Event.class.isAssignableFrom(listenerMethodParameters[0])) {
     // Parameters are invalid, throw exception
     throw new IllegalArgumentException(
         "Listener method signature invalid. Does not have a single Event subclass parameter.");
   }
   // Store the type of the Event-subclass parameter in eventType
   eventType = (Class<? extends Event>) listenerMethodParameters[0];
   // Store the listener method in listenerMethod
   this.listenerMethod = listenerMethod;
   // Make sure that listenerMethod is accessible
   if (!listenerMethod.isAccessible()) {
     listenerMethod.setAccessible(true);
   }
   // Store the listener object in listener
   this.listener = listener;
 }
 private Object invokeMethod(Method method, Object[] args) throws Throwable {
   try {
     if (!method.isAccessible()) {
       method.setAccessible(true);
     }
     return method.invoke(currentProxy, args);
   } catch (InvocationTargetException e) {
     throw e.getCause();
   }
 }
示例#13
0
 /**
  * Inject value from jndi into a setter method of an instance
  *
  * @param method
  * @param injectable
  */
 protected void injectMethod(Method method, Object injectable) {
   try {
     boolean accessibility = method.isAccessible();
     method.setAccessible(true);
     method.invoke(injectable, new Object[] {lookupInjectedValue()});
     method.setAccessible(accessibility);
   } catch (Exception e) {
     LOG.warn(e);
     throw new IllegalStateException("Inject failed for method " + method.getName());
   }
 }
示例#14
0
 @Test
 public void test_niet_bestaan_setters() {
   Method[] lijst = DIV.class.getDeclaredMethods();
   boolean probleem = false;
   for (Method m : lijst) {
     probleem &= m.isAccessible() && m.getName().startsWith("set");
   }
   if (probleem) {
     fail("there is a setter method in DIV");
   }
 }
  public static Method getDeclaredMethod(Class<?> clazz, String name, Class<?>... parameterTypes)
      throws Exception {

    Method method = clazz.getDeclaredMethod(name, parameterTypes);

    if (!method.isAccessible()) {
      method.setAccessible(true);
    }

    return method;
  }
示例#16
0
 /**
  * Adds the URL to the system class loader classpath using reflection. HACK: Uses reflection to
  * modify the class path, and assumes loader is a URLClassLoader.
  *
  * @param urls URLs to add to the system class loader classpath.
  */
 private static void addClasspath(List<URL> urls) {
   Set<URL> existing = JVMUtils.getClasspathURLs();
   for (URL url : urls) {
     if (existing.contains(url)) continue;
     try {
       Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
       if (!method.isAccessible()) method.setAccessible(true);
       method.invoke(ClassLoader.getSystemClassLoader(), url);
     } catch (Exception e) {
       throw new ReviewedStingException("Error adding url to the current classloader.", e);
     }
   }
 }
  private static final Method getDeclaredMethod(
      Class<?> owner, String methodName, Class<?>... parameterTypes)
      throws SecurityException, NoSuchMethodException {

    Method m = owner.getDeclaredMethod(methodName, parameterTypes);

    if (!m.isAccessible()) {

      m.setAccessible(true);
    }

    return m;
  }
 public QQNotifyHandlerProxy(Object proxyObject) {
   this.proxyObject = proxyObject;
   this.methodMap = new HashMap<QQNotifyEvent.Type, Method>();
   for (Method m : proxyObject.getClass().getDeclaredMethods()) {
     if (m.isAnnotationPresent(QQNotifyHandler.class)) {
       QQNotifyHandler handler = m.getAnnotation(QQNotifyHandler.class);
       this.methodMap.put(handler.value(), m);
       if (!m.isAccessible()) {
         m.setAccessible(true);
       }
     }
   }
 }
示例#19
0
    @Override
    public Object getValue(Object pojo, Method method, Object[] args) throws Throwable {
      Method targetMethod = getMethodWithMapping(pojo, method, args);

      if (targetMethod == null) {
        throw new RuntimeException("Internal error, isEligible() should be called first!");
      }

      if (!targetMethod.isAccessible()) {
        targetMethod.setAccessible(true);
      }

      return convertedValue(targetMethod.invoke(pojo, args), method.getReturnType());
    }
示例#20
0
 static {
   if (VERSION.SDK_INT >= 18) {
     try {
       sComputeFitSystemWindowsMethod =
           View.class.getDeclaredMethod(
               "computeFitSystemWindows", new Class[] {Rect.class, Rect.class});
       if (!sComputeFitSystemWindowsMethod.isAccessible()) {
         sComputeFitSystemWindowsMethod.setAccessible(true);
       }
     } catch (NoSuchMethodException e) {
       Log.d("ViewUtils", "Could not find method computeFitSystemWindows. Oh well.");
     }
   }
 }
示例#21
0
 @Nullable
 @SuppressWarnings("unchecked")
 public static <T> T invoke(@Nullable Object target, @NonNull Method method, Object... args)
     throws DynamicException {
   final boolean isAccessible = method.isAccessible();
   try {
     method.setAccessible(true);
     return (T) method.invoke(target, args);
   } catch (InvocationTargetException | IllegalAccessException e) {
     throw new DynamicException(e);
   } finally {
     method.setAccessible(isAccessible);
   }
 }
 private static Callback createBeanCallback(Class<?> callbackClass, String methodName) {
   Class<?> callbackSuperclass = callbackClass.getSuperclass();
   if (callbackSuperclass != null) {
     Callback callback = createBeanCallback(callbackSuperclass, methodName);
     if (callback != null) return callback;
   }
   for (Method method : callbackClass.getDeclaredMethods()) {
     if (!method.getName().equals(methodName)) continue;
     if (method.getParameterTypes().length != 0) continue;
     if (!method.isAccessible()) method.setAccessible(true);
     return new BeanCallback(method);
   }
   return null;
 }
示例#23
0
  /*
   * (non-Javadoc)
   *
   * @see com.absir.aop.AopProxyHandler#invoke(java.lang.Object,
   * java.lang.reflect.Method, java.lang.Object[],
   * net.sf.cglib.proxy.MethodProxy)
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
      throws Throwable {
    if (beanObject == null) {
      return methodProxy.invokeSuper(proxy, args);

    } else {
      if (!method.isAccessible()) {
        method.setAccessible(true);
      }

      return method.invoke(beanObject, args);
    }
  }
示例#24
0
  /**
   * Add a URL to the Minecraft classloader class path
   *
   * @param classUrl URL of the resource to add
   */
  private boolean addURLToClassPath(URL classUrl) {
    try {
      if (Minecraft.class.getClassLoader() instanceof URLClassLoader
          && mAddUrl != null
          && mAddUrl.isAccessible()) {
        URLClassLoader classLoader = (URLClassLoader) Minecraft.class.getClassLoader();
        mAddUrl.invoke(classLoader, classUrl);
        return true;
      }
    } catch (Throwable th) {
      logger.log(Level.WARNING, "Error adding class path entry", th);
    }

    return false;
  }
示例#25
0
 Object invokeMethod(
     XWalkExtensionClient ext, int instanceID, Object obj, String mName, JSONArray args)
     throws ReflectiveOperationException {
   if (!hasMethod(mName)) {
     throw new NoSuchMethodException("No such method:" + mName);
   }
   if (!(getMemberInfo(mName).isStatic) && !(myClass.isInstance(obj))) {
     throw new InvocationTargetException(new Exception("Invalid target to set property:" + mName));
   }
   Method m = (Method) members.get(mName).accesser;
   if (!m.isAccessible()) {
     m.setAccessible(true);
   }
   Object[] oArgs = getArgsFromJson(ext, instanceID, m, args);
   return m.invoke(obj, oArgs);
 }
 /**
  * @see javax.servlet.ServletContext#getResourcePaths(java.lang.String)
  *     <p>This method was added in the Servlet 2.3 API however the OSGi HttpService currently does
  *     not provide support for this method in the HttpContext interface. To support
  *     "getResourcePaths(...) this implementation uses reflection to check for and then call the
  *     associated HttpContext.getResourcePaths(...) method opportunistically. Null is returned if
  *     the method is not present or fails.
  */
 @SuppressWarnings("unchecked")
 public Set<String> getResourcePaths(String name) {
   if (name == null || !name.startsWith("/")) // $NON-NLS-1$
   return null;
   try {
     Method getResourcePathsMethod =
         httpContext
             .getClass()
             .getMethod("getResourcePaths", new Class[] {String.class}); // $NON-NLS-1$
     if (!getResourcePathsMethod.isAccessible()) getResourcePathsMethod.setAccessible(true);
     return (Set<String>) getResourcePathsMethod.invoke(httpContext, new Object[] {name});
   } catch (Exception e) {
     // ignore
   }
   return null;
 }
 protected Object callMethod(Object o, Class<?> clazz, String name) {
   try {
     Method m = clazz.getDeclaredMethod(name);
     boolean prev = m.isAccessible();
     m.setAccessible(true);
     try {
       return m.invoke(o);
     } finally {
       m.setAccessible(prev);
     }
   } catch (ReflectiveOperationException e) {
     return e;
   } catch (SecurityException e) {
     return e;
   }
 }
示例#28
0
  private static Object invoke(Object o, Method m)
      throws IllegalAccessException, InvocationTargetException {
    boolean access = m.isAccessible();
    m.setAccessible(true);
    try {
      LazyLoadScenario.setShouldLoad(false);

      return m.invoke(o);
    } catch (Exception e) {
      // That's fine
      return null;
    } finally {
      LazyLoadScenario.setShouldLoad(true);
      m.setAccessible(access);
    }
  }
示例#29
0
 public Object serviceInvokation(
     String actor, String serviceName, String methodName, Object[] methodParams)
     throws NotFoundException, ServiceException, IMTPException {
   AID id = new AID(actor, AID.ISLOCALNAME);
   AgentImage image = getAgentImage(id);
   ServiceHelper helper = image.getHelper(serviceName);
   if (helper == null) {
     throw new ServiceException("Service " + serviceName + "does not have a Service-helper");
   }
   BECodec codec = getBECodec(serviceName);
   Object[] decodedParams = codec.decodeParams(methodName, methodParams);
   try {
     Method m = null;
     Method[] mm = helper.getClass().getMethods();
     for (int i = 0; i < mm.length; ++i) {
       if (mm[i].getName().equals(methodName)) {
         if (isCompatible(mm[i], decodedParams)) {
           m = mm[i];
           break;
         }
       }
     }
     if (m != null) {
       if (!m.isAccessible()) {
         try {
           m.setAccessible(true);
         } catch (SecurityException se) {
           throw new NoSuchMethodException(
               "Method "
                   + methodName
                   + "() of class "
                   + getClass().getName()
                   + " not accessible.");
         }
       }
       Object result = m.invoke(helper, decodedParams);
       return codec.encodeResult(methodName, result);
     } else {
       throw new ServiceException("No valid " + methodName + " method found in service helper");
     }
   } catch (ServiceException se) {
     throw se;
   } catch (Exception e) {
     e.printStackTrace();
     throw new ServiceException("Unexpected error, ", e);
   }
 }
示例#30
0
 public static void makeOptionalFitsSystemWindows(View view) {
   if (VERSION.SDK_INT >= 16) {
     try {
       Method method = view.getClass().getMethod("makeOptionalFitsSystemWindows", new Class[0]);
       if (!method.isAccessible()) {
         method.setAccessible(true);
       }
       method.invoke(view, new Object[0]);
     } catch (NoSuchMethodException e) {
       Log.d("ViewUtils", "Could not find method makeOptionalFitsSystemWindows. Oh well...");
     } catch (InvocationTargetException e2) {
       Log.d("ViewUtils", "Could not invoke makeOptionalFitsSystemWindows", e2);
     } catch (IllegalAccessException e3) {
       Log.d("ViewUtils", "Could not invoke makeOptionalFitsSystemWindows", e3);
     }
   }
 }