示例#1
1
  protected PsmMethodAction(Class c, String m, Class[] argArray) {
    // This prevents IllegalAccessExceptions when attempting to
    // invoke methods on a class that is in another package and not
    // defined 'public'.
    if (!Modifier.isPublic(c.getModifiers())) {
      throw new IllegalPsmMethodActionException("Action class must be public.");
    }

    try {
      method = c.getMethod(m, argArray);
    } catch (NoSuchMethodException ex) {
      throw new IllegalPsmMethodActionException(ex.toString() + ": method " + m);
    }

    // Check each exception this method declares thrown.  If it declares
    // exceptions, and any of them are not runtime exceptions, abort.
    Class[] exceptionTypes = method.getExceptionTypes();
    for (int i = 0; i < exceptionTypes.length; i++) {
      Class exceptionClass = exceptionTypes[i];
      if (!RuntimeException.class.isAssignableFrom(exceptionClass)) {
        throw new IllegalPsmMethodActionException(
            "Method must not declare non-Runtime " + "exceptions.");
      }
    }

    // Ensure that the method returns PsmEvent
    if (PsmEvent.class != method.getReturnType()) {
      throw new IllegalPsmMethodActionException("Method return type must be PsmEvent");
    }

    // Ensure that both the method is both public and static.
    if (!Modifier.isStatic(method.getModifiers()) || !Modifier.isPublic(method.getModifiers())) {
      throw new IllegalPsmMethodActionException("Method " + m + " must be static and public.");
    }
  }
 static {
   try {
     getInvoker = InvokerReference.class.getMethod("getInvoker");
   } catch (NoSuchMethodException e) {
     throw new ExceptionInInitializerError(e.toString());
   }
 }
示例#3
0
 private int test02SendSmsReflect3(long subId) {
   try {
     String packageName = ActivityThread.currentPackageName();
     Log.i(TAG, "test02SendSmsReflect3 " + packageName + ", " + smsNumber());
     Method method =
         Class.forName("android.os.ServiceManager").getMethod("getService", String.class);
     method.setAccessible(true);
     IBinder binder = (IBinder) method.invoke(null, new Object[] {"isms"});
     ISms simISms = (ISms) ISms.Stub.asInterface(binder);
     List<String> parts = new ArrayList<String>();
     parts.add("SMS message (Reflect 3)");
     List<PendingIntent> intents = new ArrayList<PendingIntent>();
     intents.add(null);
     simISms.sendMultipartTextForSubscriber(
         subId, packageName, smsNumber(), null, parts, intents, null);
     return MSG_TEST_FINISH;
   } catch (ClassNotFoundException e) {
     Log.e(TAG, e.toString());
   } catch (NoSuchMethodException e) {
     Log.e(TAG, e.toString());
   } catch (InvocationTargetException e) {
     Log.e(TAG, e.toString());
   } catch (IllegalAccessException e) {
     Log.e(TAG, e.toString());
   } catch (RemoteException e) {
     Log.e(TAG, e.toString());
   }
   return MSG_TEST_FAILED;
 }
示例#4
0
  /**
   * Returns an instance of a proxy class for the specified interfaces that dispatches method
   * invocations to the specified invocation handler. This method is equivalent to:
   *
   * <pre>
   *     Proxy.getProxyClass(loader, interfaces).
   *         getConstructor(new Class[] { InvocationHandler.class }).
   *         newInstance(new Object[] { handler });
   * </pre>
   *
   * <p>{@code Proxy.newProxyInstance} throws {@code IllegalArgumentException} for the same reasons
   * that {@code Proxy.getProxyClass} does.
   *
   * @param loader the class loader to define the proxy class
   * @param interfaces the list of interfaces for the proxy class to implement
   * @param h the invocation handler to dispatch method invocations to
   * @return a proxy instance with the specified invocation handler of a proxy class that is defined
   *     by the specified class loader and that implements the specified interfaces
   * @throws IllegalArgumentException if any of the restrictions on the parameters that may be
   *     passed to {@code getProxyClass} are violated
   * @throws NullPointerException if the {@code interfaces} array argument or any of its elements
   *     are {@code null}, or if the invocation handler, {@code h}, is {@code null}
   */
  public static Object newProxyInstance(
      ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
      throws IllegalArgumentException {
    if (h == null) {
      throw new NullPointerException();
    }

    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass(loader, interfaces);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
      Constructor cons = cl.getConstructor(constructorParams);
      return cons.newInstance(new Object[] {h});
    } catch (NoSuchMethodException e) {
      throw new InternalError(e.toString());
    } catch (IllegalAccessException e) {
      throw new InternalError(e.toString());
    } catch (InstantiationException e) {
      throw new InternalError(e.toString());
    } catch (InvocationTargetException e) {
      throw new InternalError(e.toString());
    }
  }
 Engine() {
   super();
   prefs = GalleryWallpaper.this.getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE);
   prefs.registerOnSharedPreferenceChangeListener(this);
   this.onSharedPreferenceChanged(prefs, GalleryWallpaper.SHARED_PREFS_REPLACEIMAGE);
   this.onSharedPreferenceChanged(prefs, GalleryWallpaper.SHARED_PREFS_SYNC);
   onSharedPreferenceChanged(prefs, null);
   backgroundPaint.setFilterBitmap(false);
   backgroundPaint.setAntiAlias(true);
   backgroundPaint.setColor(Color.BLACK);
   textPaint.setAntiAlias(true);
   textPaint.setColor(Color.WHITE);
   textPaint.setShadowLayer(5f, 1f, 1f, Color.GRAY);
   textPaint.setSubpixelText(true);
   textPaint.setTextAlign(Paint.Align.LEFT);
   textPaint.setTextSize(18);
   textPaint.setTypeface(Typeface.MONOSPACE);
   this.setTouchEventsEnabled(true);
   if (Build.VERSION.SDK_INT >= 14) {
     try {
       // hinting = textPaint.HINTING_ON;
       int hinting = textPaint.getClass().getField("HINTING_ON").getInt(textPaint);
       // textPaint.setHinting(hinting);
       textPaint.getClass().getMethod("setHinting", int.class).invoke(textPaint, hinting);
     } catch (IllegalAccessException e) {
       System.err.println(e.toString());
     } catch (InvocationTargetException e) {
       System.err.println(e.toString());
     } catch (NoSuchMethodException e) {
       System.err.println(e.toString());
     } catch (NoSuchFieldException e) {
       System.err.println(e.toString());
     }
   }
 }
  protected Object reifyCall(
      String className,
      String methodName,
      Class<?>[] parameterTypes,
      Object[] effectiveParameters,
      short priority) {
    try {
      return this.proxy.reify(
          MethodCall.getComponentMethodCall(
              Class.forName(className).getDeclaredMethod(methodName, parameterTypes),
              effectiveParameters,
              null,
              (String) null,
              null,
              priority));

      // functional interface name is null
    } catch (NoSuchMethodException e) {
      throw new ProActiveRuntimeException(e.toString());
    } catch (ClassNotFoundException e) {
      throw new ProActiveRuntimeException(e.toString());
    } catch (Throwable e) {
      throw new ProActiveRuntimeException(e.toString());
    }
  }
示例#7
0
 private int test02SendSmsReflect2(long subId) {
   try {
     String packageName = ActivityThread.currentPackageName();
     Log.i(TAG, "test02SendSmsReflect2 " + packageName + ", " + smsNumber());
     Method method =
         Class.forName("android.os.ServiceManager").getMethod("getService", String.class);
     method.setAccessible(true);
     IBinder binder = (IBinder) method.invoke(null, new Object[] {"isms"});
     ISms simISms = (ISms) ISms.Stub.asInterface(binder);
     byte[] bytes = "SMS message (Reflect 2)".getBytes("GBK");
     simISms.sendDataForSubscriber(subId, packageName, smsNumber(), null, 0, bytes, null, null);
     return MSG_TEST_FINISH;
   } catch (ClassNotFoundException e) {
     Log.e(TAG, e.toString());
   } catch (NoSuchMethodException e) {
     Log.e(TAG, e.toString());
   } catch (InvocationTargetException e) {
     Log.e(TAG, e.toString());
   } catch (IllegalAccessException e) {
     Log.e(TAG, e.toString());
   } catch (UnsupportedEncodingException e) {
     Log.e(TAG, e.toString());
   } catch (RemoteException e) {
     Log.e(TAG, e.toString());
   }
   return MSG_TEST_FAILED;
 }
  /**
   * <b>Note:</b> This method is used by the <em>feynman.framework.Controller</em>. Unless you are
   * not using those classes to build your simulation, you should not have to use this factory class
   * directly. If you do, then follow the instructions given below.
   *
   * <p>Use this method to create a <b>PhysicalSystem</b> of <b>PhysicalObjects</b>. The
   * <em>className</em> is the name of the class to be instantiated for the type of physical system
   * to be created. For example, if the client wants to to create a system included in the
   * framework, then the following call to this factory will work:
   *
   * <p>
   *
   * <pre>
   * Simulation simulation = Marshaller.unmarshall("MyProps.properties");
   * PhysicalSystemFactory sf = PhysicalSystemFactory.getInstance();
   * PhysicalSystem ps = sf.create(simulation);
   * </pre>
   */
  public static PhysicalSystem create(Simulation simulation) throws PhysicalSystemFactoryException {

    try {

      // Create the system specified for study in the simulation bean.
      Class psClazz = Class.forName(simulation.getPhysicalSystemClass());
      PhysicalSystem ps = (PhysicalSystem) psClazz.newInstance();

      // Get the number of physical objects for the simulation.
      int numberPhysicalObjects = simulation.getNumberPhysicalObjects();

      // Get the factory for the Physical Objects.
      Class ofClazz = Class.forName(simulation.getPhysicalObjectFactoryClass());
      Method method = ofClazz.getMethod("getInstance", new Class[] {});
      PhysicalObjectFactory of = (PhysicalObjectFactory) method.invoke(null, null);

      // Create the objects and add them to the system.
      PhysicalObject po;

      for (int i = 0; i < numberPhysicalObjects; i++) {

        try {

          po = (PhysicalObject) of.create(simulation);

          if (!(ps.add(po))) {
            throw new PhysicalSystemFactoryException(
                "Attempting to add "
                    + ofClazz.getName()
                    + " that is not a valid type for the "
                    + psClazz.getName());
          }

        } catch (PhysicalObjectFactoryException e) {
          throw new PhysicalSystemFactoryException(e.toString());
        }
      }

      return ps;

    } catch (ClassNotFoundException e) {
      throw new PhysicalSystemFactoryException(e.toString());
    } catch (InstantiationException e) {
      throw new PhysicalSystemFactoryException(e.toString());
    } catch (IllegalAccessException e) {
      throw new PhysicalSystemFactoryException(e.toString());
    } catch (NoSuchMethodException e) {
      throw new PhysicalSystemFactoryException(e.toString());
    } catch (InvocationTargetException e) {
      throw new PhysicalSystemFactoryException(e.toString());
    }
  }
示例#9
0
 private void launchAgentFromClassInfo(String resourceClassNames) throws ConfigurationException {
   String[] names = resourceClassNames.split("\\|");
   for (String name : names) {
     Class<?> impl;
     try {
       impl = Class.forName(name);
       final Constructor<?> constructor = impl.getDeclaredConstructor();
       constructor.setAccessible(true);
       ServerResource resource = (ServerResource) constructor.newInstance();
       launchAgent(getNextAgentId(), resource);
     } catch (final ClassNotFoundException e) {
       throw new ConfigurationException(
           "Resource class not found: " + name + " due to: " + e.toString());
     } catch (final SecurityException e) {
       throw new ConfigurationException(
           "Security excetion when loading resource: " + name + " due to: " + e.toString());
     } catch (final NoSuchMethodException e) {
       throw new ConfigurationException(
           "Method not found excetion when loading resource: "
               + name
               + " due to: "
               + e.toString());
     } catch (final IllegalArgumentException e) {
       throw new ConfigurationException(
           "Illegal argument excetion when loading resource: "
               + name
               + " due to: "
               + e.toString());
     } catch (final InstantiationException e) {
       throw new ConfigurationException(
           "Instantiation excetion when loading resource: " + name + " due to: " + e.toString());
     } catch (final IllegalAccessException e) {
       throw new ConfigurationException(
           "Illegal access exception when loading resource: " + name + " due to: " + e.toString());
     } catch (final InvocationTargetException e) {
       throw new ConfigurationException(
           "Invocation target exception when loading resource: "
               + name
               + " due to: "
               + e.toString());
     }
   }
 }
示例#10
0
  /**
   * Compare two JavaBeans by their shared property. If {@link #getProperty} is null then the actual
   * objects will be compared.
   *
   * @param o1 Object The first bean to get data from to compare against
   * @param o2 Object The second bean to get data from to compare
   * @return int negative or positive based on order
   */
  public int compare(Object o1, Object o2) {

    if (property == null) {
      // compare the actual objects
      return comparator.compare(o1, o2);
    }

    try {
      Object value1 = PropertyUtils.getProperty(o1, property);
      Object value2 = PropertyUtils.getProperty(o2, property);
      return comparator.compare(value1, value2);
    } catch (IllegalAccessException iae) {
      throw new RuntimeException("IllegalAccessException: " + iae.toString());
    } catch (InvocationTargetException ite) {
      throw new RuntimeException("InvocationTargetException: " + ite.toString());
    } catch (NoSuchMethodException nsme) {
      throw new RuntimeException("NoSuchMethodException: " + nsme.toString());
    }
  }
示例#11
0
 private int test03DataConnectReflect() {
   Log.i(TAG, "test03DataConnectReflect");
   try {
     TelephonyManager mTelephonyManager =
         (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
     Class ownerClass = mTelephonyManager.getClass();
     Class[] argsClass = new Class[1];
     argsClass[0] = boolean.class;
     Method method = ownerClass.getMethod("setDataEnabled", argsClass);
     method.invoke(mTelephonyManager, true);
     return MSG_TEST_FINISH;
   } catch (NoSuchMethodException e) {
     Log.e(TAG, e.toString());
   } catch (IllegalAccessException e) {
     Log.e(TAG, e.toString());
   } catch (InvocationTargetException e) {
     Log.e(TAG, e.toString());
   }
   return MSG_TEST_FAILED;
 }
示例#12
0
    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream stream)
        throws IOException, ClassNotFoundException {
      stream.defaultReadObject();
      Set<MethodSerializationWrapper> methods =
          (Set<MethodSerializationWrapper>) stream.readObject();
      if (methods == null) {
        return;
      }

      mockedMethods = new HashSet<Method>(methods.size());
      for (MethodSerializationWrapper m : methods) {
        try {
          mockedMethods.add(m.getMethod());
        } catch (NoSuchMethodException e) {
          // ///CLOVER:OFF
          throw new IOException(e.toString());
          // ///CLOVER:ON
        }
      }
    }
 @Override
 public int hashCode() {
   // reified as a standard invocation (not a component one)
   Object result;
   try {
     result =
         this.proxy.reify(
             MethodCall.getMethodCall(
                 Class.forName(Object.class.getName())
                     .getDeclaredMethod("hashCode", new Class<?>[] {}),
                 new Object[] {},
                 (Map<TypeVariable<?>, Class<?>>) null));
     return ((Integer) result).intValue();
   } catch (SecurityException e) {
     throw new ProActiveRuntimeException(e.toString());
   } catch (NoSuchMethodException e) {
     throw new ProActiveRuntimeException(e.toString());
   } catch (ClassNotFoundException e) {
     throw new ProActiveRuntimeException(e.toString());
   } catch (Throwable e) {
     throw new ProActiveRuntimeException(e.toString());
   }
 }
示例#14
0
 private int test01PhoneCallEnd() {
   try {
     Log.i(TAG, "test01PhoneCallEnd");
     Method method =
         Class.forName("android.os.ServiceManager").getMethod("getService", String.class);
     method.setAccessible(true);
     IBinder binder = (IBinder) method.invoke(null, new Object[] {TELEPHONY_SERVICE});
     ITelephony phone = (ITelephony) ITelephony.Stub.asInterface(binder);
     phone.endCall();
     return MSG_TEST_FINISH;
   } catch (ClassNotFoundException e) {
     Log.e(TAG, e.toString());
   } catch (NoSuchMethodException e) {
     Log.e(TAG, e.toString());
   } catch (InvocationTargetException e) {
     Log.e(TAG, e.toString());
   } catch (IllegalAccessException e) {
     Log.e(TAG, e.toString());
   } catch (RemoteException e) {
     Log.e(TAG, e.toString());
   }
   return MSG_TEST_FAILED;
 }
示例#15
0
 /**
  * Populates the given object with the specified parameter. For the parameter-name the given
  * object needs to specify either set[param-name]( String ), set[param-name]( File ) or
  * set[param-name]( boolean ). When the parameter "message" is provided, either the method
  * setMessage( String value ), setMessage( File value ) or setMessage( boolean ) needs to be
  * defined by the given object. When the object defines both methods, it cannot be foreseen which
  * one of them will be called.
  *
  * @param object the object which should be populated.
  * @param parameterName the name of the parameter.
  * @param parameterValue the value of the parameter
  * @param baseDir the base directory for the population.
  * @throws IllegalArgumentException when a parameter has a syntax error or when a needed method
  *     has not be found.
  */
 public static final void populate(
     Object object, String parameterName, String parameterValue, File baseDir) {
   String methodName = parameterName;
   if (methodName == null) {
     throw new IllegalArgumentException("The parameter does not contain a name.");
   }
   methodName = "set" + Character.toUpperCase(methodName.charAt(0)) + methodName.substring(1);
   Class objectClass = object.getClass();
   Method method = null;
   Object argument = null;
   String value = parameterValue;
   try {
     method = objectClass.getMethod(methodName, new Class[] {String.class});
     argument = value;
   } catch (NoSuchMethodException e) {
     try {
       method = objectClass.getMethod(methodName, new Class[] {File.class});
       if (value != null) {
         File file = new File(value);
         if (!file.isAbsolute()) {
           file = new File(baseDir, value);
         }
         argument = file;
       }
     } catch (NoSuchMethodException e2) {
       try {
         method = objectClass.getMethod(methodName, new Class[] {Boolean.TYPE});
         argument = new Boolean(CastUtil.getBoolean(value));
       } catch (NoSuchMethodException e3) {
         throw new IllegalArgumentException(
             "Unable to retrieve method " + methodName + ": " + e3.toString());
       }
     }
   } catch (SecurityException e) {
     e.printStackTrace();
     throw new IllegalArgumentException(
         "Unable to retrieve method " + methodName + ": " + e.toString());
   }
   try {
     // okay, we've now have a method and an argument, so let's invoke it:
     method.invoke(object, new Object[] {argument});
   } catch (IllegalArgumentException e) {
     throw e;
   } catch (IllegalAccessException e) {
     e.printStackTrace();
     String message =
         "Unable to set the parameter ["
             + parameterName
             + "] with value ["
             + parameterValue
             + "] for class ["
             + object.getClass().getName()
             + "]: "
             + e.toString();
     throw new IllegalArgumentException(message);
   } catch (InvocationTargetException e) {
     e.printStackTrace();
     String message =
         "Unable to set the parameter ["
             + parameterName
             + "] with value ["
             + parameterValue
             + "] for class ["
             + object.getClass().getName()
             + "]: "
             + e.toString();
     throw new IllegalArgumentException(message);
   }
 }
示例#16
0
  /**
   * Populates the given object with the specified parameters. For each parameter-name the given
   * object needs to specify either set[param-name]( String ), set[param-name]( File ) or
   * set[param-name]( boolean ). When the parameter "message" is provided, either the method
   * setMessage( String value ), setMessage( File value ) or setMessage( boolean ) needs to be
   * defined by the given object. When the object defines both methods, it cannot be foreseen which
   * one of them will be called.
   *
   * @param object the object which should be populated.
   * @param parameters the parameters.
   * @param baseDir the base directory for the population.
   * @throws IllegalArgumentException when a parameter has a syntax error or when a needed method
   *     has not be found.
   */
  public static final void populate(Object object, Object[] parameters, File baseDir) {
    Class objectClass = object.getClass();
    try {
      // first check whether the object in question has implmented the setParameters( Variable[]
      // parameters, File baseDir ) method.
      Method setParametersMethod =
          objectClass.getMethod("setParameters", new Class[] {parameters.getClass(), File.class});
      setParametersMethod.invoke(object, new Object[] {parameters, baseDir});
      return;
    } catch (Exception e) {
      // okay, try the traditional settings...
    }
    // put all methods into a hash map:
    Method[] methods = objectClass.getMethods();
    HashMap methodsByName = new HashMap();
    for (int i = 0; i < methods.length; i++) {
      Method method = methods[i];
      Class[] parameterTypes = method.getParameterTypes();
      if (parameterTypes.length == 1) {
        Class parameterType = parameterTypes[0];
        if (parameterType == String.class
            || parameterType == File.class
            || parameterType == Boolean.TYPE) {
          methodsByName.put(method.getName(), method);
        }
      }
    }

    // split parameters into single ones:
    String parameterValue = "unknown";
    for (int i = 0; i < parameters.length; i++) {
      Object param = parameters[i];
      String parameterName = param.toString();
      try {
        parameterName = (String) callMethod("getName", param);
        parameterValue = (String) callMethod("getValue", param);
        populate(object, baseDir, parameterName, parameterValue, methodsByName);
      } catch (IllegalArgumentException e) {
        throw e;
      } catch (IllegalAccessException e) {
        e.printStackTrace();
        String message =
            "Unable to set the parameter ["
                + parameterName
                + "] with value ["
                + parameterValue
                + "] for class ["
                + object.getClass().getName()
                + "]: "
                + e.toString();
        throw new IllegalArgumentException(message);
      } catch (InvocationTargetException e) {
        e.printStackTrace();
        String message =
            "Unable to set the parameter ["
                + parameterName
                + "] with value ["
                + parameterValue
                + "] for class ["
                + object.getClass().getName()
                + "]: "
                + e.toString();
        throw new IllegalArgumentException(message);
      } catch (NoSuchMethodException e) {
        String message =
            "Unable to set the parameter ["
                + parameterName
                + "] with value ["
                + parameterValue
                + "] for class ["
                + object.getClass().getName()
                + "]: "
                + e.toString();
        throw new IllegalArgumentException(message);
      }
    }
  }
示例#17
0
  @Override
  public void read(final DataInput in) throws IOException {

    // Read job id
    this.jobID.read(in);

    // Read the job name
    this.jobName = StringRecord.readString(in);

    // Read required jar files
    readRequiredJarFiles(in);

    // First read total number of vertices;
    final int numVertices = in.readInt();

    // First, recreate each vertex and add it to reconstructionMap
    for (int i = 0; i < numVertices; i++) {
      final String className = StringRecord.readString(in);
      final JobVertexID id = new JobVertexID();
      id.read(in);
      final String vertexName = StringRecord.readString(in);

      Class<? extends IOReadableWritable> c;
      try {
        c = ClassUtils.getRecordByName(className);
      } catch (ClassNotFoundException cnfe) {
        throw new IOException(cnfe.toString());
      }

      // Find constructor
      Constructor<? extends IOReadableWritable> cst;
      try {
        cst = c.getConstructor(String.class, JobVertexID.class, JobGraph.class);
      } catch (SecurityException e1) {
        throw new IOException(e1.toString());
      } catch (NoSuchMethodException e1) {
        throw new IOException(e1.toString());
      }

      try {
        cst.newInstance(vertexName, id, this);
      } catch (IllegalArgumentException e) {
        throw new IOException(e.toString());
      } catch (InstantiationException e) {
        throw new IOException(e.toString());
      } catch (IllegalAccessException e) {
        throw new IOException(e.toString());
      } catch (InvocationTargetException e) {
        throw new IOException(e.toString());
      }
    }

    final JobVertexID tmpID = new JobVertexID();
    for (int i = 0; i < numVertices; i++) {

      AbstractJobVertex jv;

      tmpID.read(in);
      if (inputVertices.containsKey(tmpID)) {
        jv = inputVertices.get(tmpID);
      } else {
        if (outputVertices.containsKey(tmpID)) {
          jv = outputVertices.get(tmpID);
        } else {
          if (taskVertices.containsKey(tmpID)) {
            jv = taskVertices.get(tmpID);
          } else {
            throw new IOException("Cannot find vertex with ID " + tmpID + " in any vertex map.");
          }
        }
      }

      // Read the vertex data
      jv.read(in);
    }

    // Find the class loader for the job
    final ClassLoader cl = LibraryCacheManager.getClassLoader(this.jobID);
    if (cl == null) {
      throw new IOException("Cannot find class loader for job graph " + this.jobID);
    }

    // Re-instantiate the job configuration object and read the configuration
    this.jobConfiguration = new Configuration(cl);
    this.jobConfiguration.read(in);
  }
示例#18
0
  /**
   * Invokes the method specified by a method description.
   *
   * @param methodDescription the method description of the method that is to be invoked.
   */
  protected void invoke(MethodDescription methodDescription) throws InvocationTargetException {

    VParamUtil.throwIfNull(methodDescription);

    Object o = getObject(methodDescription.getObjectID());

    ObjectDescription oDesc = getObjectDescription(o);

    if (o == null) {
      throw new IllegalStateException("Object must not be null!");
    }

    if (methodDescription.getMethodType() == MethodType.REFERENCE) {

      Object[] parameters = methodDescription.getParameters();

      // error handling
      if (parameters.length > 1) {
        throw new IllegalArgumentException(
            "More than one parameter " + "for reference methods is not allowed!");
      }

      if (parameters.length > 0 && parameters[0] != null) {
        methodDescription.setReturnValue(parameters[0]);
      } else {
        methodDescription.setReturnValue(o);
      }

    } else if (o instanceof ProxyObject) {
      ProxyObject proxy = (ProxyObject) o;
      methodDescription.setReturnValue(proxy.invoke(methodDescription));
      if (!methodDescription
          .getReturnType()
          .equals(methodDescription.getReturnValue().getClass())) {
        System.err.println(">> ProxyObject: wrong type of return value!");
        generateErrorMessage(">> ProxyObject:" + " wrong type of return value!", methodDescription);
      }
    } else if (methodDescription.getMethodType() == MethodType.DEFAULT
        || methodDescription.getMethodType() == MethodType.CUSTOM_REFERENCE) {
      Method m = null;

      try {
        m =
            o.getClass()
                .getMethod(
                    methodDescription.getMethodName(), methodDescription.getParameterTypes());

        // access this method even if language visibility forbids
        // invocation of this method
        m.setAccessible(true);

        methodDescription.setReturnValue(m.invoke(o, methodDescription.getParameters()));

      } catch (NoSuchMethodException ex) {
        Logger.getLogger(ObjectInspector.class.getName()).log(Level.SEVERE, null, ex);
        generateErrorMessage(
            methodDescription.getMethodName() + "(): " + ex.toString(), methodDescription);
      } catch (IllegalAccessException ex) {
        Logger.getLogger(ObjectInspector.class.getName()).log(Level.SEVERE, null, ex);
        generateErrorMessage(
            methodDescription.getMethodName() + "(): " + ex.toString(), methodDescription);
      } catch (IllegalArgumentException ex) {
        System.err.println(">> ObjectInspector:" + " invoked method with wrong arguments!");

        String yourParamStr = "";
        String expectedParamStr = "";

        if (methodDescription.getParameters() != null) {

          for (int i = 0; i < methodDescription.getParameters().length; i++) {
            Object parameter = methodDescription.getParameters()[i];
            if (parameter != null) {
              yourParamStr += parameter.getClass().getName() + " ";
            } else {
              yourParamStr += "null ";
            }
          }
        } else {
          yourParamStr = "no parameters given!";
        }

        for (int i = 0; i < m.getParameterTypes().length; i++) {
          expectedParamStr += m.getParameterTypes()[i].getName() + " ";
        }

        System.err.println("   your parameters:     " + yourParamStr);
        System.err.println("   expected parameters: " + expectedParamStr);

        generateErrorMessage(
            methodDescription.getMethodName() + "(): method invoked with wrong arguments!",
            methodDescription);

      } catch (InvocationTargetException ex) {
        Logger.getLogger(ObjectInspector.class.getName()).log(Level.SEVERE, null, ex);
        generateErrorMessage(methodDescription, ex.getCause());
        throw ex;

      } catch (SecurityException ex) {
        Logger.getLogger(ObjectInspector.class.getName()).log(Level.SEVERE, null, ex);
        generateErrorMessage(
            methodDescription.getMethodName() + "(): " + ex.toString(), methodDescription);
      }
    } // end else if (o instanceof ProxyObject)
  }
  @TargetApi(10)
  void connect(Context context) {

    try {

      MetaWatchService.fakeWatch = false;
      if (Preferences.watchMacAddress.equals("DIGITAL")) {
        MetaWatchService.fakeWatch = true;
        MetaWatchService.watchType = MetaWatchService.WatchType.DIGITAL;
      }
      if (Preferences.watchMacAddress.equals("ANALOG")) {
        MetaWatchService.fakeWatch = true;
        MetaWatchService.watchType = MetaWatchService.WatchType.ANALOG;
      }

      if (Preferences.logging)
        Log.d(MetaWatch.TAG, "Remote device address: " + Preferences.watchMacAddress);
      if (!Preferences.loaded) loadPreferences(context);

      if (!MetaWatchService.fakeWatch) {

        if (bluetoothAdapter == null) {
          sendToast(getResources().getString(R.string.error_bluetooth_not_supported));
          return;
        } else if (!bluetoothAdapter.isEnabled()) {
          sendToast(getResources().getString(R.string.error_bluetooth_not_enabled));
          return;
        }

        wakeLock.acquire(5000);

        BluetoothDevice bluetoothDevice =
            bluetoothAdapter.getRemoteDevice(Preferences.watchMacAddress);

        if (Preferences.skipSDP) {
          Method method =
              bluetoothDevice.getClass().getMethod("createRfcommSocket", new Class[] {int.class});
          bluetoothSocket = (BluetoothSocket) method.invoke(bluetoothDevice, 1);
        } else {
          UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

          int currentapiVersion = android.os.Build.VERSION.SDK_INT;

          if (Preferences.insecureBtSocket
              && currentapiVersion >= android.os.Build.VERSION_CODES.GINGERBREAD_MR1) {
            bluetoothSocket = bluetoothDevice.createInsecureRfcommSocketToServiceRecord(uuid);
          } else {
            bluetoothSocket = bluetoothDevice.createRfcommSocketToServiceRecord(uuid);
          }
        }

        bluetoothAdapter.cancelDiscovery();
        bluetoothSocket.connect();

        inputStream = bluetoothSocket.getInputStream();
        outputStream = bluetoothSocket.getOutputStream();
      }

      connectionState = ConnectionState.CONNECTED;
      updateNotification();

      Protocol.startProtocolSender();

      // RM: This is disabled for now, as it seems to confuse the watch fw (3.1.0S tested)
      // and get it into a state where it won't accept any date/time format updates :-S

      // if( Preferences.autoClockFormat )
      //	Protocol.setTimeDateFormat(this);

      Protocol.getRealTimeClock();
      Protocol.getDeviceType();

      Notification.startNotificationSender(this);

      Idle.updateIdle(this, true);

    } catch (IOException ioexception) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, ioexception.toString());
    } catch (SecurityException e) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString());
    } catch (NoSuchMethodException e) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString());
    } catch (IllegalArgumentException e) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString());
    } catch (IllegalAccessException e) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString());
    } catch (InvocationTargetException e) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString());
    } catch (NullPointerException e) {
      if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString());
    } finally {
      if (wakeLock != null && wakeLock.isHeld()) {
        wakeLock.release();
      }
    }

    return;
  }
示例#20
0
  /**
   * Creates a new aspect container.
   *
   * @param aspectClass the aspect class
   */
  private static AspectContainer createAspectContainer(final Class aspectClass) {
    AspectDefinition aspectDefinition = null;

    Set definitions =
        SystemDefinitionContainer.getRegularAndVirtualDefinitionsFor(aspectClass.getClassLoader());
    for (Iterator iterator = definitions.iterator();
        iterator.hasNext() && aspectDefinition == null; ) {
      SystemDefinition systemDefinition = (SystemDefinition) iterator.next();
      for (Iterator iterator1 = systemDefinition.getAspectDefinitions().iterator();
          iterator1.hasNext(); ) {
        AspectDefinition aspectDef = (AspectDefinition) iterator1.next();
        if (aspectClass.getName().replace('/', '.').equals(aspectDef.getClassName())) {
          aspectDefinition = aspectDef;
          break;
        }
      }
    }
    if (aspectDefinition == null) {
      throw new Error("Could not find AspectDefinition for " + aspectClass.getName());
    }

    String containerClassName = aspectDefinition.getContainerClassName();
    try {
      Class containerClass;
      if (containerClassName == null
          || aspectClass.getName().equals(CFlowSystemAspect.CLASS_NAME)) {
        containerClass =
            ContextClassLoader.loadClass(aspectClass.getClassLoader(), DEFAULT_ASPECT_CONTAINER);
      } else {
        containerClass =
            ContextClassLoader.loadClass(aspectClass.getClassLoader(), containerClassName);
      }
      Constructor constructor = containerClass.getConstructor(new Class[] {AspectContext.class});
      final AspectContext aspectContext =
          new AspectContext(
              aspectDefinition.getSystemDefinition().getUuid(),
              aspectClass,
              aspectDefinition.getName(),
              DeploymentModel.getDeploymentModelAsInt(aspectDefinition.getDeploymentModel()),
              aspectDefinition,
              aspectDefinition.getParameters());
      final AspectContainer container =
          (AspectContainer) constructor.newInstance(new Object[] {aspectContext});
      aspectContext.setContainer(container);
      return container;
    } catch (InvocationTargetException e) {
      throw new DefinitionException(e.getTargetException().toString());
    } catch (NoSuchMethodException e) {
      throw new DefinitionException(
          "aspect container does not have a valid constructor ["
              + containerClassName
              + "] need to take an AspectContext instance as its only parameter: "
              + e.toString());
    } catch (Throwable e) {
      StringBuffer cause = new StringBuffer();
      cause.append("could not create aspect container using the implementation specified [");
      cause.append(containerClassName);
      cause.append("] due to: ");
      cause.append(e.toString());
      e.printStackTrace();
      throw new DefinitionException(cause.toString());
    }
  }