src/xwalk/runtime/android/core_internal/src/org/xwalk/core/internal/extension/XWalkExtensionClientImpl.java

   1 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.xwalk.core.internal.extension;
   6
   7 import android.content.Context;
   8 import android.content.Intent;
   9 import android.util.Log;
  10
  11 import java.lang.reflect.InvocationTargetException;
  12 import java.lang.reflect.Method;
  13
  14 /**
  15  * The public base class of xwalk external extensions. It acts a bridge class from
  16  * runtime to runtime client. The objects of class 'XWalkExtensionClient' in runtime
  17  * client side will be passed into this class because we need to call its methods.
  18  */
  19 class XWalkExtensionClientImpl extends XWalkExtension {
  20
  21     private static final String TAG = XWalkExtensionClientImpl.class.getName();
  22     private Object mExtensionClient;
  23     private Method mOnMessage;
  24     private Method mOnSyncMessage;
  25     private Method mOnStart;
  26     private Method mOnResume;
  27     private Method mOnPause;
  28     private Method mOnStop;
  29     private Method mOnDestroy;
  30     private Method mOnActivityResult;
  31
  32     public XWalkExtensionClientImpl(String name, String jsApi,
  33             XWalkExtensionContextWrapper context, Object extensionClient) {
  34         super(name, jsApi, context);
  35
  36         mExtensionClient = extensionClient;
  37         mOnMessage = lookupMethod("onMessage", int.class, String.class);
  38         mOnSyncMessage = lookupMethod("onSyncMessage", int.class, String.class);
  39         mOnStart = lookupMethod("onStart");
  40         mOnResume = lookupMethod("onResume");
  41         mOnPause = lookupMethod("onPause");
  42         mOnStop = lookupMethod("onStop");
  43         mOnDestroy = lookupMethod("onDestroy");
  44         mOnActivityResult = lookupMethod("onActivityResult", int.class, int.class, Intent.class);
  45     }
  46
  47     @Override
  48     public void onMessage(int extensionInstanceID, String message) {
  49         invokeMethod(mOnMessage, mExtensionClient, extensionInstanceID, message);
  50     }
  51
  52     @Override
  53     public String onSyncMessage(int extensionInstanceID, String message) {
  54         return (String) invokeMethod(mOnSyncMessage, mExtensionClient, extensionInstanceID, message);
  55     }
  56
  57     @Override
  58     public void onStart() {
  59         invokeMethod(mOnStart, mExtensionClient);
  60     }
  61
  62     @Override
  63     public void onResume() {
  64         invokeMethod(mOnResume, mExtensionClient);
  65     }
  66
  67     @Override
  68     public void onPause() {
  69         invokeMethod(mOnPause, mExtensionClient);
  70     }
  71
  72     @Override
  73     public void onStop() {
  74         invokeMethod(mOnStop, mExtensionClient);
  75     }
  76
  77     @Override
  78     public void onDestroy() {
  79         invokeMethod(mOnDestroy, mExtensionClient);
  80     }
  81
  82     @Override
  83     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  84         invokeMethod(mOnActivityResult, mExtensionClient, requestCode, resultCode, data);
  85     }
  86
  87     private Method lookupMethod(String method, Class<?>... parameters) {
  88         Class<?> clientClass = mExtensionClient.getClass();
  89         try {
  90             return clientClass.getMethod(method, parameters);
  91         } catch (NoSuchMethodException e) {
  92             handleException(e);
  93         }
  94         return null;
  95     }
  96
  97     private static Object invokeMethod(Method method, Object instance, Object... parameters) {
  98         Object result = null;
  99         if (method != null) {
 100             try {
 101                 result = method.invoke(instance, parameters);
 102             } catch (IllegalArgumentException e) {
 103                 handleException(e);
 104             } catch (IllegalAccessException e) {
 105                 handleException(e);
 106             } catch (InvocationTargetException e) {
 107                 handleException(e);
 108             } catch (NullPointerException e) {
 109                 handleException(e);
 110             }
 111         }
 112         return result;
 113     }
 114
 115     private static void handleException(Exception e) {
 116         Log.e(TAG, "Error in calling methods of external extensions. " + e.toString());
 117         e.printStackTrace();
 118     }
 119 }