Example usage for android.app Activity runOnUiThread

List of usage examples for android.app Activity runOnUiThread

Introduction

In this page you can find the example usage for android.app Activity runOnUiThread.

Prototype

public final void runOnUiThread(Runnable action) 

Source Link

Document

Runs the specified action on the UI thread.

Usage

From source file:com.native5.plugins.ActionBarPlugin.java

@Override
public boolean execute(final String action, final JSONArray args, final CallbackContext callbackContext)
        throws JSONException {
    if (!plugin_actions.contains(action)) {
        return false;
    }/*w ww .j a  va  2  s .c  o  m*/

    final Activity ctx = (Activity) cordova;

    if ("isAvailable".equals(action)) {
        JSONObject result = new JSONObject();
        result.put("value", ctx.getWindow().hasFeature(Window.FEATURE_ACTION_BAR));
        callbackContext.success(result);
        return true;
    }

    final ActionBar bar = ctx.getActionBar();
    if (bar == null) {
        Window window = ctx.getWindow();
        if (!window.hasFeature(Window.FEATURE_ACTION_BAR)) {
            callbackContext
                    .error("ActionBar feature not available, Window.FEATURE_ACTION_BAR must be enabled!");
        } else {
            callbackContext.error("Failed to get ActionBar");
        }

        return true;
    }

    if (menu == null) {
        callbackContext.error("Options menu not initialised");
        return true;
    }

    final StringBuffer error = new StringBuffer();
    JSONObject result = new JSONObject();

    if ("isShowing".equals(action)) {
        result.put("value", bar.isShowing());
    } else if ("getHeight".equals(action)) {
        result.put("value", bar.getHeight());
    } else if ("getDisplayOptions".equals(action)) {
        result.put("value", bar.getDisplayOptions());
    } else if ("getNavigationMode".equals(action)) {
        result.put("value", bar.getNavigationMode());
    } else if ("getSelectedNavigationItem".equals(action)) {
        result.put("value", bar.getSelectedNavigationIndex());
    } else if ("getSubtitle".equals(action)) {
        result.put("value", bar.getSubtitle());
    } else if ("getTitle".equals(action)) {
        result.put("value", bar.getTitle());
    } else {
        try {
            JSONException exception = new Runnable() {
                public JSONException exception = null;

                public void run() {
                    try {
                        // This is a bit of a hack (should be specific to the request, not global)
                        bases = new String[] { removeFilename(webView.getOriginalUrl()),
                                removeFilename(webView.getUrl()) };

                        if ("show".equals(action)) {
                            LOG.d("native5-action-bar", "Showing Action Bar");
                            bar.show();
                        } else if ("hide".equals(action)) {
                            bar.hide();
                        } else if ("setMenu".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("menu can not be null");
                                return;
                            }

                            menu_definition = args.getJSONArray(0);

                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                                ctx.invalidateOptionsMenu();
                            }
                        } else if ("setTabs".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("menu can not be null");
                                return;
                            }

                            bar.removeAllTabs();
                            tab_callbacks.clear();

                            if (!buildTabs(bar, args.getJSONArray(0))) {
                                error.append("Invalid tab bar definition");
                            }
                        } else if ("setDisplayHomeAsUpEnabled".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("showHomeAsUp can not be null");
                                return;
                            }

                            bar.setDisplayHomeAsUpEnabled(args.getBoolean(0));
                        } else if ("setDisplayOptions".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("options can not be null");
                                return;
                            }

                            final int options = args.getInt(0);
                            bar.setDisplayOptions(options);
                        } else if ("setDisplayShowHomeEnabled".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("showHome can not be null");
                                return;
                            }

                            bar.setDisplayShowHomeEnabled(args.getBoolean(0));
                        } else if ("setDisplayShowTitleEnabled".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("showTitle can not be null");
                                return;
                            }

                            bar.setDisplayShowTitleEnabled(args.getBoolean(0));
                        } else if ("setDisplayUseLogoEnabled".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("useLogo can not be null");
                                return;
                            }

                            bar.setDisplayUseLogoEnabled(args.getBoolean(0));
                        } else if ("setHomeButtonEnabled".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("enabled can not be null");
                                return;
                            }

                            bar.setHomeButtonEnabled(args.getBoolean(0));
                        } else if ("setIcon".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("icon can not be null");
                                return;
                            }

                            Drawable drawable = getDrawableForURI(args.getString(0));
                            bar.setIcon(drawable);
                        } else if ("setListNavigation".equals(action)) {
                            JSONArray items = null;
                            if (args.isNull(0) == false) {
                                items = args.getJSONArray(0);
                            }

                            navigation_adapter.setItems(items);
                            bar.setListNavigationCallbacks(navigation_adapter, navigation_listener);
                        } else if ("setLogo".equals(action)) {
                            String uri = args.getString(0);
                            if (args.isNull(0)) {
                                error.append("logo can not be null");
                                return;
                            }

                            //                        try {
                            //                           InputStream ims = ctx.getAssets().open(uri);
                            Drawable drawable = getDrawableForURI(uri);
                            //                                 Drawable.createFromStream(ims, null);
                            bar.setLogo(drawable);
                            bar.setBackgroundDrawable(getDrawableForURI("images/logo-bg.png"));
                            //                        } catch (IOException e) {
                            //                           e.printStackTrace();
                            //                        }
                        } else if ("setNavigationMode".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("mode can not be null");
                                return;
                            }

                            final int mode = args.getInt(0);
                            bar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
                        } else if ("setSelectedNavigationItem".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("position can not be null");
                                return;
                            }
                            bar.setSelectedNavigationItem(args.getInt(0));
                        } else if ("setSelectedTab".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("position can not be null");
                                return;
                            }
                            LOG.d("setSelectedTab", bar.getTabCount() + "");
                            bar.selectTab(bar.getTabAt(args.getInt(0)));
                        } else if ("setSubtitle".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("subtitle can not be null");
                                return;
                            }

                            bar.setSubtitle(args.getString(0));
                        } else if ("setTitle".equals(action)) {
                            if (args.isNull(0)) {
                                error.append("title can not be null");
                                return;
                            }

                            bar.setTitle(args.getString(0));
                        }
                    } catch (JSONException e) {
                        exception = e;
                    } finally {
                        synchronized (this) {
                            this.notify();
                        }
                    }
                }

                // Run task synchronously
                {
                    synchronized (this) {
                        ctx.runOnUiThread(this);
                        this.wait();
                    }
                }
            }.exception;

            if (exception != null) {
                throw exception;
            }
        } catch (InterruptedException e) {
            error.append("Function interrupted on UI thread");
        }
    }

    if (error.length() == 0) {
        if (result.length() > 0) {
            callbackContext.success(result);
        } else {
            callbackContext.success();
        }
    } else {
        callbackContext.error(error.toString());
    }

    return true;
}

From source file:com.razerzone.store.sdk.engine.gamemaker.Plugin.java

public static String init(final String secretApiKey) {

    if (sEnableLogging) {
        Log.d(TAG, "init: secretApiKey=" + secretApiKey);
    }/*from w w  w. jav  a 2 s  .com*/

    final Activity activity = Plugin.getRelay().getCurrentActivity();
    if (null == activity) {
        Log.d(TAG, "Current activity is null");
        return sFalse;
    } else {
        Log.d(TAG, "Current activity is valid");
    }

    final FrameLayout content = (FrameLayout) activity.findViewById(android.R.id.content);
    if (null == content) {
        Log.d(TAG, "Content is null");
        return sFalse;
    } else {
        Runnable runnable = new Runnable() {
            public void run() {
                Log.d(TAG, "Disable screensaver");
                content.setKeepScreenOn(true);

                Log.d(TAG, "Add inputView");
                sInputView = new InputView(activity);

                Bundle developerInfo = null;
                try {
                    developerInfo = StoreFacade.createInitBundle(secretApiKey);
                } catch (InvalidParameterException e) {
                    Log.e(TAG, e.getMessage());
                    activity.finish();
                    return;
                }

                if (sEnableLogging) {
                    Log.d(TAG, "developer_id=" + developerInfo.getString(StoreFacade.DEVELOPER_ID));
                }

                if (sEnableLogging) {
                    Log.d(TAG, "developer_public_key length="
                            + developerInfo.getByteArray(StoreFacade.DEVELOPER_PUBLIC_KEY).length);
                }

                sInitCompleteListener = new CancelIgnoringResponseListener<Bundle>() {
                    @Override
                    public void onSuccess(Bundle bundle) {
                        if (sEnableLogging) {
                            Log.d(TAG, "InitCompleteListener: onSuccess");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessInit");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                        sInitialized = true;
                    }

                    @Override
                    public void onFailure(int errorCode, String errorMessage, Bundle optionalData) {
                        if (sEnableLogging) {
                            Log.d(TAG, "InitCompleteListener: onFailure errorCode=" + errorCode
                                    + " errorMessage=" + errorMessage);
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureInit");
                            JSONObject data = new JSONObject();
                            data.put("errorCode", Integer.toString(errorCode));
                            data.put("errorMessage", errorMessage);
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                sStoreFacade = StoreFacade.getInstance();
                try {
                    sStoreFacade.init(activity, developerInfo, sInitCompleteListener);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                sRequestLoginListener = new ResponseListener<Void>() {
                    @Override
                    public void onSuccess(Void result) {
                        if (sEnableLogging) {
                            Log.d(TAG, "sRequestLoginListener: onSuccess");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessRequestLogin");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onFailure(int errorCode, String errorMessage, Bundle optionalData) {
                        if (sEnableLogging) {
                            Log.e(TAG, "sRequestLoginListener: onFailure errorCode=" + errorCode
                                    + " errorMessage=" + errorMessage);
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureRequestLogin");
                            JSONObject data = new JSONObject();
                            data.put("errorCode", Integer.toString(errorCode));
                            data.put("errorMessage", errorMessage);
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onCancel() {
                        if (sEnableLogging) {
                            Log.d(TAG, "sRequestLoginListener: onCancel");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onCancelRequestLogin");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                sRequestGamerInfoListener = new ResponseListener<GamerInfo>() {
                    @Override
                    public void onSuccess(GamerInfo info) {
                        if (null == info) {
                            Log.e(TAG, "GamerInfo is null!");
                            return;
                        }
                        if (sEnableLogging) {
                            Log.d(TAG, "sRequestGamerInfoListener: onSuccess uuid=" + info.getUuid()
                                    + " username=" + info.getUsername());
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessRequestGamerInfo");
                            JSONObject data = new JSONObject();
                            data.put("uuid", info.getUuid());
                            data.put("username", info.getUsername());
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onFailure(int errorCode, String errorMessage, Bundle optionalData) {
                        if (sEnableLogging) {
                            Log.e(TAG, "sRequestGamerInfoListener: onFailure errorCode=" + errorCode
                                    + " errorMessage=" + errorMessage);
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureRequestGamerInfo");
                            JSONObject data = new JSONObject();
                            data.put("errorCode", Integer.toString(errorCode));
                            data.put("errorMessage", errorMessage);
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onCancel() {
                        if (sEnableLogging) {
                            Log.d(TAG, "sRequestGamerInfoListener: onCancel");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onCancelRequestGamerInfo");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                sRequestProductsListener = new ResponseListener<List<Product>>() {
                    @Override
                    public void onSuccess(final List<Product> products) {
                        if (null == products) {
                            Log.e(TAG, "Products are null!");
                            return;
                        }
                        if (sEnableLogging) {
                            Log.i(TAG, "sRequestProductsListener: onSuccess");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessRequestProducts");
                            JSONArray data = new JSONArray();
                            int index = 0;
                            for (Product product : products) {
                                JSONObject item = new JSONObject();
                                try {
                                    item.put("currencyCode", product.getCurrencyCode());
                                    item.put("description", product.getDescription());
                                    item.put("identifier", product.getIdentifier());
                                    item.put("localPrice", product.getLocalPrice());
                                    item.put("name", product.getName());
                                    item.put("originalPrice", product.getOriginalPrice());
                                    item.put("percentOff", product.getPercentOff());
                                    item.put("developerName", product.getDeveloperName());
                                    data.put(index, item);
                                    ++index;
                                } catch (JSONException e2) {
                                }
                            }
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onFailure(int errorCode, String errorMessage, Bundle optionalData) {
                        if (sEnableLogging) {
                            Log.e(TAG, "sRequestProductsListener: onFailure errorCode=" + errorCode
                                    + " errorMessage=" + errorMessage);
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureRequestProducts");
                            JSONObject data = new JSONObject();
                            data.put("errorCode", Integer.toString(errorCode));
                            data.put("errorMessage", errorMessage);
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onCancel() {
                        if (sEnableLogging) {
                            Log.i(TAG, "sRequestProductsListener: onCancel");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onCancelRequestProducts");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                sRequestPurchaseListener = new ResponseListener<PurchaseResult>() {

                    @Override
                    public void onSuccess(PurchaseResult result) {
                        if (null == result) {
                            Log.e(TAG, "PurchaseResult is null!");
                            return;
                        }
                        if (sEnableLogging) {
                            Log.i(TAG, "sRequestPurchaseListener: onSuccess");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessRequestPurchase");
                            JSONObject data = new JSONObject();
                            data.put("identifier", result.getProductIdentifier());
                            data.put("ownerId", result.getOrderId());
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onFailure(int errorCode, String errorMessage, Bundle optionalData) {
                        if (sEnableLogging) {
                            Log.e(TAG, "sRequestPurchaseListener: onFailure errorCode=" + errorCode
                                    + " errorMessage=" + errorMessage);
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureRequestPurchase");
                            JSONObject data = new JSONObject();
                            data.put("errorCode", Integer.toString(errorCode));
                            data.put("errorMessage", errorMessage);
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onCancel() {
                        if (sEnableLogging) {
                            Log.i(TAG, "sRequestPurchaseListener: onCancel");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onCancelRequestPurchase");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                sRequestReceiptsListener = new ResponseListener<Collection<Receipt>>() {

                    @Override
                    public void onSuccess(Collection<Receipt> receipts) {
                        if (null == receipts) {
                            Log.e(TAG, "Receipts are null!");
                            return;
                        }
                        if (sEnableLogging) {
                            Log.i(TAG, "requestReceipts onSuccess: received " + receipts.size() + " receipts");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessRequestReceipts");
                            JSONArray data = new JSONArray();
                            int index = 0;
                            for (Receipt receipt : receipts) {
                                JSONObject item = new JSONObject();
                                try {
                                    item.put("identifier", receipt.getIdentifier());
                                    item.put("purchaseDate", receipt.getPurchaseDate());
                                    item.put("gamer", receipt.getGamer());
                                    item.put("uuid", receipt.getUuid());
                                    item.put("localPrice", receipt.getLocalPrice());
                                    item.put("currency", receipt.getCurrency());
                                    item.put("generatedDate", receipt.getGeneratedDate());
                                    data.put(index, item);
                                    ++index;
                                } catch (JSONException e2) {
                                }
                            }
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onFailure(int errorCode, String errorMessage, Bundle optionalData) {
                        if (sEnableLogging) {
                            Log.e(TAG, "requestReceipts onFailure: errorCode=" + errorCode + " errorMessage="
                                    + errorMessage);
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureRequestReceipts");
                            JSONObject data = new JSONObject();
                            data.put("errorCode", Integer.toString(errorCode));
                            data.put("errorMessage", errorMessage);
                            json.put("data", data);
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onCancel() {
                        if (sEnableLogging) {
                            Log.i(TAG, "requestReceipts onCancel");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onCancelRequestReceipts");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                sShutdownListener = new CancelIgnoringResponseListener<Void>() {
                    @Override
                    public void onSuccess(Void aVoid) {
                        if (sEnableLogging) {
                            Log.i(TAG, "shutdown onSuccess");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onSuccessShutdown");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }

                    @Override
                    public void onFailure(int i, String s, Bundle bundle) {
                        if (sEnableLogging) {
                            Log.i(TAG, "shutdown onFailure");
                        }
                        JSONObject json = new JSONObject();
                        try {
                            json.put("method", "onFailureShutdown");
                        } catch (JSONException e1) {
                        }
                        String jsonData = json.toString();
                        sAsyncResults.add(jsonData);
                    }
                };

                Controller.init(activity);
            }
        };
        activity.runOnUiThread(runnable);
    }

    return sTrue;
}