Java Code Examples for com.facebook.react.bridge.ReadableMap#getBoolean()

@ReactMethod
public void configure(
        final ReadableMap config,
        final Promise promise
) {
    final ReadableArray scopes = config.hasKey("scopes") ? config.getArray("scopes") : Arguments.createArray();
    final String webClientId = config.hasKey("webClientId") ? config.getString("webClientId") : null;
    final boolean offlineAccess = config.hasKey("offlineAccess") && config.getBoolean("offlineAccess");
    final boolean forceCodeForRefreshToken = config.hasKey("forceCodeForRefreshToken") && config.getBoolean("forceCodeForRefreshToken");
    final String accountName = config.hasKey("accountName") ? config.getString("accountName") : null;
    final String hostedDomain = config.hasKey("hostedDomain") ? config.getString("hostedDomain") : null;

    GoogleSignInOptions options = getSignInOptions(createScopesArray(scopes), webClientId, offlineAccess, forceCodeForRefreshToken, accountName, hostedDomain);
    _apiClient = GoogleSignIn.getClient(getReactApplicationContext(), options);
    promise.resolve(null);
}
 

/**
 * 是否启用自动刷新
 * @param view
 * @param autoRefresh
 */
@ReactProp(name = "autoRefresh",defaultBoolean = false)
public void setAutoRefresh(ReactSmartRefreshLayout view, ReadableMap autoRefresh){
    boolean isAutoRefresh=false;Integer time=null;
    if(autoRefresh.hasKey("refresh")){
        isAutoRefresh=autoRefresh.getBoolean("refresh");
    }
    if(autoRefresh.hasKey("time")){
        time=autoRefresh.getInt("time");
    }
    if(isAutoRefresh==true){
        if(time!=null && time>0){
            view.autoRefresh(time);
        }else{
            view.autoRefresh();
        }
    }
}
 

public TcpSocketServer(final ConcurrentHashMap<Integer, TcpSocketClient> socketClients, final TcpReceiverTask.OnDataReceivedListener receiverListener, final Integer id,
                       final ReadableMap options) throws IOException {
    super(id);
    // Get data from options
    int port = options.getInt("port");
    String address = options.getString("host");
    this.socketClients = socketClients;
    clientSocketIds = (1 + getId()) * 1000;
    // Get the addresses
    InetAddress localInetAddress = InetAddress.getByName(address);
    // Create the socket
    serverSocket = new ServerSocket(port, 50, localInetAddress);
    // setReuseAddress
    try {
        boolean reuseAddress = options.getBoolean("reuseAddress");
        serverSocket.setReuseAddress(reuseAddress);
    } catch (Exception e) {
        // Default to true
        serverSocket.setReuseAddress(true);
    }
    mReceiverListener = receiverListener;
    listen();
}
 

@Override
public void resetConfig(ReadableMap config) {
  mSpringStiffness = config.getDouble("stiffness");
  mSpringDamping = config.getDouble("damping");
  mSpringMass = config.getDouble("mass");
  mInitialVelocity = mCurrentState.velocity;
  mEndValue = config.getDouble("toValue");
  mRestSpeedThreshold = config.getDouble("restSpeedThreshold");
  mDisplacementFromRestThreshold = config.getDouble("restDisplacementThreshold");
  mOvershootClampingEnabled = config.getBoolean("overshootClamping");
  mIterations = config.hasKey("iterations") ? config.getInt("iterations") : 1;
  mHasFinished = mIterations == 0;
  mCurrentLoop = 0;
  mTimeAccumulator = 0;
  mSpringStarted = false;
}
 

void setActions(@Nullable ReadableArray actions) {
  Menu menu = getMenu();
  menu.clear();
  mActionsHolder.clear();
  if (actions != null) {
    for (int i = 0; i < actions.size(); i++) {
      ReadableMap action = actions.getMap(i);

      MenuItem item = menu.add(Menu.NONE, Menu.NONE, i, action.getString(PROP_ACTION_TITLE));

      if (action.hasKey(PROP_ACTION_ICON)) {
        setMenuItemIcon(item, action.getMap(PROP_ACTION_ICON));
      }

      int showAsAction = action.hasKey(PROP_ACTION_SHOW)
          ? action.getInt(PROP_ACTION_SHOW)
          : MenuItem.SHOW_AS_ACTION_NEVER;
      if (action.hasKey(PROP_ACTION_SHOW_WITH_TEXT) &&
          action.getBoolean(PROP_ACTION_SHOW_WITH_TEXT)) {
        showAsAction = showAsAction | MenuItem.SHOW_AS_ACTION_WITH_TEXT;
      }
      item.setShowAsAction(showAsAction);
    }
  }
}
 

public void showCallout(ReadableMap args) {
    ReadableMap rawPoint = args.getMap("point");
    if (!rawPoint.hasKey("latitude") || !rawPoint.hasKey("longitude")) {
        return;
    }
    Double latitude = rawPoint.getDouble("latitude");
    Double longitude = rawPoint.getDouble("longitude");
    if (latitude == 0 || longitude == 0) {
        return;
    }
    String title = "";
    String text = "";
    Boolean shouldRecenter = false;

    if(args.hasKey("title")) {
        title = args.getString("title");
    }
    if(args.hasKey("text")) {
        text = args.getString("text");
    }
    if(args.hasKey("shouldRecenter")) {
        shouldRecenter = args.getBoolean("shouldRecenter");
    }

    // Displaying the callout
    Point agsPoint = new Point(longitude, latitude, SpatialReferences.getWgs84());

    // Set callout content
    View calloutContent = callout.getContent();
    ((TextView) calloutContent.findViewById(R.id.title)).setText(title);
    ((TextView) calloutContent.findViewById(R.id.text)).setText(text);
    callout.setLocation(agsPoint);
    callout.show();
    Log.i("AGS",callout.isShowing()+" " + calloutContent.getWidth() + " " + calloutContent.getHeight());
    if (shouldRecenter) {
        mapView.setViewpointCenterAsync(agsPoint);
    }
}
 

private void reconcileStatusBarStyle(
    Activity activity,
    ReadableMap prev,
    ReadableMap next,
    boolean firstCall
) {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    reconcileStatusBarStyleOnM(
        activity,
        prev,
        next,
        firstCall
    );
  }

  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    reconcileStatusBarStyleOnLollipop(
        activity,
        prev,
        next,
        firstCall
    );
  }

  if (firstCall || boolHasChanged("statusBarHidden", prev, next)) {
    boolean hidden = false;
    if (next.hasKey("statusBarHidden")) {
      hidden = next.getBoolean("statusBarHidden");
    }
    if (hidden) {
      activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
      activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
    } else {
      activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
      activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }
  }
}
 

private static LocationOptions fromReactMap(ReadableMap map) {
  // precision might be dropped on timeout (double -> int conversion), but that's OK
  long timeout =
    map.hasKey("timeout") ? (long) map.getDouble("timeout") : Long.MAX_VALUE;
  double maximumAge =
    map.hasKey("maximumAge") ? map.getDouble("maximumAge") : Double.POSITIVE_INFINITY;
  boolean highAccuracy = !map.hasKey("enableHighAccuracy") || map.getBoolean("enableHighAccuracy");
  float distanceFilter = map.hasKey("distanceFilter") ?
    (float) map.getDouble("distanceFilter") :
    RCT_DEFAULT_LOCATION_ACCURACY;

  return new LocationOptions(timeout, maximumAge, highAccuracy, distanceFilter);
}
 

/**
 * toObject extracts a value from a {@link ReadableMap} by its key,
 * and returns a POJO representing that object.
 *
 * @param readableMap The Map to containing the value to be converted
 * @param key         The key for the value to be converted
 * @return The converted POJO
 */
public static Object toObject(@Nullable ReadableMap readableMap, String key) {
    if (readableMap == null) {
        return null;
    }

    Object result;

    ReadableType readableType = readableMap.getType(key);
    switch (readableType) {
        case Null:
            result = key;
            break;
        case Boolean:
            result = readableMap.getBoolean(key);
            break;
        case Number:
            // Can be int or double.
            double tmp = readableMap.getDouble(key);
            if (tmp == (int) tmp) {
                result = (int) tmp;
            } else {
                result = tmp;
            }
            break;
        case String:
            result = readableMap.getString(key);
            break;
        case Map:
            result = toMap(readableMap.getMap(key));
            break;
        case Array:
            result = toList(readableMap.getArray(key));
            break;
        default:
            throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
    }

    return result;
}
 

private boolean addTabs(TabLayoutView view, ReadableArray tabsSettings) {
	if (view != null) {
		if (tabsSettings != null) {
			ReadableMap tabSettingsMap = null;

			view.removeAllTabs();
			for (int i = 0; i < tabsSettings.size(); i++) {
				tabSettingsMap = tabsSettings.getMap(i);
				if (tabSettingsMap != null) {
					if (tabSettingsMap.hasKey("customView")) {
						boolean customView = tabSettingsMap.getBoolean("customView");
						if (customView) {
							view.attachCustomTab(tabSettingsMap);
						} else {
							view.attachTab(tabSettingsMap);
						}
					}
				} else {
					return false;
				}
			}

			return true;
		}
	}

	return false;
}
 

@ReactProp(name = PROP_SOURCE)
public void setPath(final VLCPlayerView playerView, ReadableMap map) {
    String path = map.getString("uri");
    boolean autoPlay = map.getBoolean("autoplay");
    playerView.setAutoPlay(autoPlay);
    playerView.setFilePath(path);
}
 

public static @Nullable Boolean getBoolean(@NonNull ReadableMap map, @NonNull String key) {
    if (!map.hasKey(key)) {
        return null;
    }

    return map.getBoolean(key);
}
 

/**
 * 群角色管理
 * @param params
 * @param callback
 */
@ReactMethod
public void setGroupAdmin(ReadableMap params, Callback callback){
    Logger.i("setGroupAdmin:" + params.toString());
    String groupId = params.getString("groupId");
    String xmppid = params.getString("xmppid");
    String name = params.getString("name");
    boolean isAdmin = params.getBoolean("isAdmin");
    ConnectionUtil.getInstance().setGroupAdmin(groupId,xmppid,name,isAdmin);
}
 

public void makeTabItem(
      ReactBottomNavigation bottomNavigation,
      Menu menu,
      int index,
      Integer itemId,
      ReadableMap config
  ) {

    Log.d(TAG, "makeTabItem");

    MenuItem item = menu.add(
        Menu.NONE,
        itemId,
        Menu.NONE,
        config.getString("title")
    );

    if (config.hasKey("image")) {
      bottomNavigation.setMenuItemIcon(item, config.getMap("image"));
    } else {
      // TODO(lmr): this probably isn't the best default.
      item.setIcon(android.R.drawable.btn_radio);
    }

    if (config.hasKey("enabled")) {
      boolean enabled = config.getBoolean("enabled");
      item.setEnabled(enabled);
    }

    // not sure if we want/need to set anything on the itemview itself. hacky.
//    BottomNavigationMenuView menuView = (BottomNavigationMenuView) bottomNavigation.getChildAt(0);
//    BottomNavigationItemView itemView = (BottomNavigationItemView)menuView.getChildAt(index);
  }
 

private void openFilePicker(final ReadableMap props, final Callback onDone, final Callback onCancel) {
  MaterialFilePicker picker = new MaterialFilePicker();
  picker = picker.withActivity(getCurrentActivity());
  picker = picker.withRequestCode(1);

  String filter = props.getString("filter");
  boolean filterDirectories = props.getBoolean("filterDirectories");
  String path = props.getString("path");
  boolean hiddenFiles = props.getBoolean("hiddenFiles");
  boolean closeMenu = props.getBoolean("closeMenu");
  String title = props.getString("title");

  if (filter.length() > 0) {
    picker = picker.withFilter(Pattern.compile(filter));
  }

  picker = picker.withFilterDirectories(filterDirectories);

  if (path.length() > 0) {
    picker = picker.withRootPath(path);
  }

  picker = picker.withHiddenFiles(hiddenFiles);
  picker = picker.withCloseMenu(closeMenu);

  picker = picker.withTitle(title);

  this.onDone = onDone;
  this.onCancel = onCancel;

  picker.start();
}
 

@ReactMethod
public void update(
        ReadableMap param,
        final Callback callback) {

    WritableNativeMap map = new WritableNativeMap();
    //  @{@"is_ok": @YES, @"errorMsg": @""};
    boolean is_ok = false;

    Activity activity =  getCurrentActivity();
    if(activity != null) {
        // TODO get param
        String fullpackageUrl = param.getString("bundleUrl");
        String fullpackageMd5 = param.getString("zipMd5");
        String patchUrl = param.getString("patchUrl");
        String patchMd5 = param.getString("patchMd5");
        String fullMd5 = param.getString("bundleMd5");
        String bundleName = param.getString("bundleName");

        // TODO switch update type
        if(param.getBoolean("new")){
            String updateType = param.getString("update_type");
            if(updateType.equalsIgnoreCase(FULL_UPDATE)){
                // todo full update
                is_ok = QTalkPatchDownloadHelper.downloadFullPackageAndCheck(fullpackageUrl,
                        fullpackageMd5, bundleName, QTalkSearchRNViewInstanceManager.JS_BUNDLE_NAME_ZIP_NAME,
                        QTalkSearchRNViewInstanceManager.getLocalBundlePath(activity),
                        QTalkSearchRNViewInstanceManager.CACHE_BUNDLE_NAME);

            } else if(updateType.equalsIgnoreCase(PATCH_UPDATE)) {
                // todo patch update
                is_ok = QTalkPatchDownloadHelper.downloadPatchAndCheck(patchUrl,
                        patchMd5, fullMd5,
                        QTalkSearchRNViewInstanceManager.getLocalBundlePath(activity),
                        QTalkSearchRNViewInstanceManager.CACHE_BUNDLE_NAME,
                        QTalkSearchRNViewInstanceManager.JS_BUNDLE_NAME);
            } else if(updateType.equalsIgnoreCase(AUTO_UPDATE)){
                // todo auto update
                // first patch, if patch error full update
                is_ok = QTalkPatchDownloadHelper.downloadPatchAndCheck(patchUrl,
                        patchMd5, fullMd5,
                        QTalkSearchRNViewInstanceManager.getLocalBundlePath(activity),
                        QTalkSearchRNViewInstanceManager.CACHE_BUNDLE_NAME,
                        QTalkSearchRNViewInstanceManager.JS_BUNDLE_NAME);
                if(!is_ok){
                    is_ok = QTalkPatchDownloadHelper.downloadFullPackageAndCheck(fullpackageUrl,
                            fullpackageMd5, bundleName,
                            QTalkSearchRNViewInstanceManager.JS_BUNDLE_NAME_ZIP_NAME,
                            QTalkSearchRNViewInstanceManager.getLocalBundlePath(activity),
                            QTalkSearchRNViewInstanceManager.CACHE_BUNDLE_NAME);
                }

            }
        }
    }

    map.putBoolean("is_ok", is_ok);
    map.putString("errorMsg", "");

    if(is_ok){
        CommonConfig.mainhandler.post(new Runnable() {
            @Override
            public void run() {
                QTalkSearchActivity.clearBridge();
            }
        });
    }

    callback.invoke(map);
}
 

static YandexMetricaConfig toYandexMetricaConfig(ReadableMap configMap) {
    YandexMetricaConfig.Builder builder = YandexMetricaConfig.newConfigBuilder(configMap.getString("apiKey"));

    if (configMap.hasKey("appVersion")) {
        builder.withAppVersion(configMap.getString("appVersion"));
    }
    if (configMap.hasKey("crashReporting")) {
        builder.withCrashReporting(configMap.getBoolean("crashReporting"));
    }
    if (configMap.hasKey("firstActivationAsUpdate")) {
        builder.handleFirstActivationAsUpdate(configMap.getBoolean("firstActivationAsUpdate"));
    }
    if (configMap.hasKey("installedAppCollecting")) {
        builder.withInstalledAppCollecting(configMap.getBoolean("installedAppCollecting"));
    }
    if (configMap.hasKey("location")) {
        builder.withLocation(toLocation(configMap.getMap("location")));
    }
    if (configMap.hasKey("locationTracking")) {
        builder.withLocationTracking(configMap.getBoolean("locationTracking"));
    }
    if (configMap.hasKey("logs") && configMap.getBoolean("logs")) {
        builder.withLogs();
    }
    if (configMap.hasKey("maxReportsInDatabaseCount")) {
        builder.withMaxReportsInDatabaseCount(configMap.getInt("maxReportsInDatabaseCount"));
    }
    if (configMap.hasKey("nativeCrashReporting")) {
        builder.withNativeCrashReporting(configMap.getBoolean("nativeCrashReporting"));
    }
    if (configMap.hasKey("preloadInfo")) {
        builder.withPreloadInfo(toPreloadInfo(configMap.getMap("preloadInfo")));
    }
    if (configMap.hasKey("sessionTimeout")) {
        builder.withSessionTimeout(configMap.getInt("sessionTimeout"));
    }
    if (configMap.hasKey("statisticsSending")) {
        builder.withStatisticsSending(configMap.getBoolean("statisticsSending"));
    }

    return builder.build();
}
 

@ReactMethod
public void register(ReadableMap config, Promise promise) {
    ReactNativeNotificationHubUtil notificationHubUtil = ReactNativeNotificationHubUtil.getInstance();
    String connectionString = config.getString(KEY_REGISTRATION_CONNECTIONSTRING);
    if (connectionString == null) {
        promise.reject(ERROR_INVALID_ARGUMENTS, ERROR_INVALID_CONNECTION_STRING);
        return;
    }

    String hubName = config.getString(KEY_REGISTRATION_HUBNAME);
    if (hubName == null) {
        promise.reject(ERROR_INVALID_ARGUMENTS, ERROR_INVALID_HUBNAME);
        return;
    }

    String senderID = config.getString(KEY_REGISTRATION_SENDERID);
    if (senderID == null) {
        promise.reject(ERROR_INVALID_ARGUMENTS, ERROR_INVALID_SENDER_ID);
        return;
    }

    String[] tags = null;
    if (config.hasKey(KEY_REGISTRATION_TAGS) && !config.isNull(KEY_REGISTRATION_TAGS)) {
        ReadableArray tagsJson = config.getArray(KEY_REGISTRATION_TAGS);
        tags = new String[tagsJson.size()];
        for (int i = 0; i < tagsJson.size(); ++i) {
            tags[i] = tagsJson.getString(i);
        }
    }

    ReactContext reactContext = getReactApplicationContext();
    notificationHubUtil.setConnectionString(reactContext, connectionString);
    notificationHubUtil.setHubName(reactContext, hubName);
    notificationHubUtil.setSenderID(reactContext, senderID);
    notificationHubUtil.setTemplated(reactContext, false);
    notificationHubUtil.setTags(reactContext, tags);

    if (config.hasKey(KEY_REGISTRATION_CHANNELNAME)) {
        String channelName = config.getString(KEY_REGISTRATION_CHANNELNAME);
        notificationHubUtil.setChannelName(reactContext, channelName);
    }

    if (config.hasKey(KEY_REGISTRATION_CHANNELDESCRIPTION)) {
        String channelDescription = config.getString(KEY_REGISTRATION_CHANNELDESCRIPTION);
        notificationHubUtil.setChannelDescription(reactContext, channelDescription);
    }

    if (config.hasKey(KEY_REGISTRATION_CHANNELIMPORTANCE)) {
        int channelImportance = config.getInt(KEY_REGISTRATION_CHANNELIMPORTANCE);
        notificationHubUtil.setChannelImportance(reactContext, channelImportance);
    }

    if (config.hasKey(KEY_REGISTRATION_CHANNELSHOWBADGE)) {
        boolean channelShowBadge = config.getBoolean(KEY_REGISTRATION_CHANNELSHOWBADGE);
        notificationHubUtil.setChannelShowBadge(reactContext, channelShowBadge);
    }

    if (config.hasKey(KEY_REGISTRATION_CHANNELENABLELIGHTS)) {
        boolean channelEnableLights = config.getBoolean(KEY_REGISTRATION_CHANNELENABLELIGHTS);
        notificationHubUtil.setChannelEnableLights(reactContext, channelEnableLights);
    }

    if (config.hasKey(KEY_REGISTRATION_CHANNELENABLEVIBRATION)) {
        boolean channelEnableVibration = config.getBoolean(KEY_REGISTRATION_CHANNELENABLEVIBRATION);
        notificationHubUtil.setChannelEnableVibration(reactContext, channelEnableVibration);
    }

    String uuid = notificationHubUtil.getUUID(reactContext);
    if (uuid == null) {
        uuid = ReactNativeUtil.genUUID();
        notificationHubUtil.setUUID(reactContext, uuid);
    }

    GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
    int resultCode = apiAvailability.isGooglePlayServicesAvailable(reactContext);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (apiAvailability.isUserResolvableError(resultCode)) {
            UiThreadUtil.runOnUiThread(
                    new GoogleApiAvailabilityRunnable(
                            getCurrentActivity(),
                            apiAvailability,
                            resultCode));
            promise.reject(ERROR_PLAY_SERVICES, ERROR_PLAY_SERVICES_DISABLED);
        } else {
            promise.reject(ERROR_PLAY_SERVICES, ERROR_PLAY_SERVICES_UNSUPPORTED);
        }
        return;
    }

    Intent intent = ReactNativeNotificationHubUtil.IntentFactory.createIntent(
            reactContext, ReactNativeRegistrationIntentService.class);
    ReactNativeRegistrationIntentService.enqueueWork(reactContext, intent);

    WritableMap res = Arguments.createMap();
    res.putString(KEY_PROMISE_RESOLVE_UUID, uuid);
    promise.resolve(res);
}
 

protected void setYAxisConfig(YAxis axis, ReadableMap propMap) {
    if (BridgeUtils.validate(propMap, ReadableType.Number, "axisMaxValue")) {
        axis.setAxisMaxValue((float) propMap.getDouble("axisMaxValue"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Number, "axisMinValue")) {
        axis.setAxisMinValue((float) propMap.getDouble("axisMinValue"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Boolean, "inverted")) {
        axis.setInverted(propMap.getBoolean("inverted"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Number, "spaceTop")) {
        axis.setSpaceTop((float) propMap.getDouble("spaceTop"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Number, "spaceBottom")) {
        axis.setSpaceBottom((float) propMap.getDouble("spaceBottom"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Boolean, "showOnlyMinMax")) {
        axis.setShowOnlyMinMax(propMap.getBoolean("showOnlyMinMax"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Number, "labelCount")) {
        boolean labelCountForce = false;
        if (BridgeUtils.validate(propMap, ReadableType.Boolean, "labelCountForce")) {
            labelCountForce = propMap.getBoolean("labelCountForce");
        }
        axis.setLabelCount(propMap.getInt("labelCount"), labelCountForce);
    }
    if (BridgeUtils.validate(propMap, ReadableType.String, "position")) {
        axis.setPosition(YAxis.YAxisLabelPosition.valueOf(propMap.getString("position")));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Number, "granularity")) {
        axis.setGranularity((float) propMap.getDouble("granularity"));
    }
    if (BridgeUtils.validate(propMap, ReadableType.Boolean, "granularityEnabled")) {
        axis.setGranularityEnabled(propMap.getBoolean("granularityEnabled"));
    }


    // formatting
    if (BridgeUtils.validate(propMap, ReadableType.String, "valueFormatter")) {
        String valueFormatter = propMap.getString("valueFormatter");

        if ("largeValue".equals(valueFormatter)) {
            axis.setValueFormatter(new LargeValueFormatter());
        } else if ("percent".equals(valueFormatter)) {
            axis.setValueFormatter(new PercentFormatter());
        } else {
            axis.setValueFormatter(new CustomFormatter(valueFormatter));
        }
    }

    // TODO docs says the remaining config needs to be applied before setting data. Test it
    // zero line
    if (BridgeUtils.validate(propMap, ReadableType.Map, "zeroLine")) {
        ReadableMap zeroLineConfig = propMap.getMap("zeroLine");

        if (BridgeUtils.validate(zeroLineConfig, ReadableType.Boolean, "enabled")) {
            axis.setDrawZeroLine(zeroLineConfig.getBoolean("enabled"));
        }
        if (BridgeUtils.validate(zeroLineConfig, ReadableType.Number, "lineWidth")) {
            axis.setZeroLineWidth((float) zeroLineConfig.getDouble("lineWidth"));
        }
        if (BridgeUtils.validate(zeroLineConfig, ReadableType.String, "lineColor")) {
            axis.setZeroLineColor(Color.parseColor(zeroLineConfig.getString("lineColor")));
        }
    }
}
 

@ReactProp(name = "source")
    public void setSource(PLVideoView mVideoView, ReadableMap source) {
        AVOptions options = new AVOptions();
        String uri = source.getString("uri");
        boolean mediaController = source.hasKey("controller") && source.getBoolean("controller");
        int avFrameTimeout = source.hasKey("timeout") ? source.getInt("timeout") : -1;        //10 * 1000 ms
        boolean liveStreaming = source.hasKey("live") && source.getBoolean("live");  //1 or 0 // 1 -> live
        boolean codec = source.hasKey("hardCodec") && source.getBoolean("hardCodec");  //1 or 0  // 1 -> hw codec enable, 0 -> disable [recommended]
        // the unit of timeout is ms
        if (avFrameTimeout >= 0) {
            options.setInteger(AVOptions.KEY_GET_AV_FRAME_TIMEOUT, avFrameTimeout);
        }
        // Some optimization with buffering mechanism when be set to 1
        if (liveStreaming) {
            options.setInteger(AVOptions.KEY_LIVE_STREAMING, 1);
        } else {
            options.setInteger(AVOptions.KEY_LIVE_STREAMING, 0);
        }
//        }

        // 1 -> hw codec enable, 0 -> disable [recommended]
        if (codec) {
            options.setInteger(AVOptions.KEY_MEDIACODEC, 1);
        } else {
            options.setInteger(AVOptions.KEY_MEDIACODEC, 0);
        }

        mVideoView.setAVOptions(options);

        // After setVideoPath, the play will start automatically
        // mVideoView.start() is not required

        mVideoView.setVideoPath(uri);

//        if (mediaController) {
//            // You can also use a custom `MediaController` widget
//            MediaController mMediaController = new MediaController(reactContext, false, isLiveStreaming(uri));
//            mVideoView.setMediaController(mMediaController);
//        }

    }