org.bukkit.plugin.RegisteredServiceProvider Java Examples

public static void initHooks() {
    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
    RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager().getRegistration(Permission.class);

    if (economyProvider != null) {
        economyHook = economyProvider.getProvider();
    }
    else {
        FunnyGuilds.getInstance().getPluginLogger().warning("No economy provider found, some features may not be available");
    }

    if (permissionProvider != null) {
        permissionHook = permissionProvider.getProvider();
    }
    else {
        FunnyGuilds.getInstance().getPluginLogger().warning("No permission provider found, some features may not be available");
    }
}
 

@Override
public void hook() {
    RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager()
            .getRegistration(net.milkbowl.vault.permission.Permission.class);
    if (permissionProvider != null) {
        permission = permissionProvider.getProvider();
    }
    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager()
            .getRegistration(net.milkbowl.vault.economy.Economy.class);
    if (economyProvider != null) {
        economy = economyProvider.getProvider();
    }
    if (economy != null) {
        plugin.registerEvents("money", MoneyEvent.class);
        plugin.registerConditions("money", MoneyCondition.class);
        plugin.registerVariable("money", MoneyVariable.class);
    } else {
        LogUtils.getLogger().log(Level.WARNING, "There is no economy plugin on the server!");
    }
    if (permission != null) {
        plugin.registerEvents("permission", PermissionEvent.class);
    } else {
        LogUtils.getLogger().log(Level.WARNING, "Could not get permission provider!");
    }
}
 

/**
 * Economy (soft-dependency on Vault)
 * - If a Vault-based economy was not found, disable the bounty system
 */
private void setupEconomy() {
    if (Bukkit.getPluginManager().getPlugin("Vault") != null) {
        RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServicesManager().getRegistration(Economy.class);
        if (economyProvider != null) {
            economy = economyProvider.getProvider();
        }
    }

    if (economy == null) {
        instance.getLogger().warning("Bounty-system [disabled], Vault economy not found");
        for (Permission permission : Bukkit.getPluginManager().getDefaultPermissions(false)) {
            if (permission.getName().startsWith("globalwarming.bounty")) {
                Bukkit.getPluginManager().getPermission(permission.getName())
                        .setDefault(PermissionDefault.FALSE);
            }
        }
    } else {
        instance.getLogger().info("Bounty-system [enabled], Vault economy found");
    }
}
 

boolean setupEconomy(ClaimChunk instance) {
    this.instance = instance;

    // Check if Vault is present
    if (instance.getServer().getPluginManager().getPlugin("Vault") == null) return false;

    // Get the Vault service if it is present
    RegisteredServiceProvider<Economy> rsp = instance.getServer().getServicesManager().getRegistration(Economy.class);

    // Check if the service is valid
    if (rsp == null) return false;

    // Update current economy handler
    econ = rsp.getProvider();

    // Success
    return true;
}
 

public Permission getPermissions() {
    if (permission != null) {
        return permission;
    } else {
        try {
            Class.forName("net.milkbowl.vault.permission.Permission");
            RegisteredServiceProvider<Permission> provider = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
            if (provider == null) {
                DiscordSRV.debug("Can't access permissions: registration provider was null");
                return null;
            }
            return permission = provider.getProvider();
        } catch (ClassNotFoundException e) {
            if (!warnedAboutMissingVault) {
                DiscordSRV.error("Group synchronization failed: Vault classes couldn't be found (did it enable properly?). Vault is required for synchronization to work.");
                warnedAboutMissingVault = true;
            }
            return null;
        }
    }
}
 

/**
 * Returns the Vault Permission interface.
 *
 * @param server the bukkit server instance
 * @return the vault permission instance
 * @throws PermissionHandlerException if the vault permission instance cannot be retrieved
 */
@VisibleForTesting
Permission getVaultPermission(Server server) throws PermissionHandlerException {
    // Get the permissions provider service
    RegisteredServiceProvider<Permission> permissionProvider = server
        .getServicesManager().getRegistration(Permission.class);
    if (permissionProvider == null) {
        throw new PermissionHandlerException("Could not load permissions provider service");
    }

    // Get the Vault provider and make sure it's valid
    Permission vaultPerms = permissionProvider.getProvider();
    if (vaultPerms == null) {
        throw new PermissionHandlerException("Could not load Vault permissions provider");
    }
    return vaultPerms;
}
 

/**
 * Sets up the permissions instance
 * 
 * @return true if successful
 */
public static boolean setupPermissions() {
    RegisteredServiceProvider<Permission> permissionProvider = ASkyBlock.getPlugin().getServer().getServicesManager()
            .getRegistration(net.milkbowl.vault.permission.Permission.class);
    if (permissionProvider != null) {
        permission = permissionProvider.getProvider();
    }
    return (permission != null);
}
 

/**
 * Sets up the economy instance
 * 
 * @return true if successful
 */
public static boolean setupEconomy() {
    RegisteredServiceProvider<Economy> economyProvider = ASkyBlock.getPlugin().getServer().getServicesManager()
            .getRegistration(net.milkbowl.vault.economy.Economy.class);
    if (economyProvider != null) {
        econ = economyProvider.getProvider();
    }
    return econ != null;
}
 

public static boolean setupEconomy() {
	if (Bukkit.getPluginManager().getPlugin("Vault") == null) {
		return false;
	}
	RegisteredServiceProvider<Economy> rsp = Bukkit.getServicesManager().getRegistration(Economy.class);
	if (rsp == null) {
		return false;
	}
	economy = rsp.getProvider();
	return economy != null;
}
 

public <T> T getService(Class<T> service) {
	if (!isProvided()) {
		throw new IllegalStateException("Hook is not provided");
	}
	
	RegisteredServiceProvider<T> provider = servicesManager.getRegistration(service);
	if (provider == null) {
		throw new IllegalStateException("RegisteredServiceProvider is null for service " + service.getName());
	}
	
	return provider.getProvider();
}
 

/**
 * Get Economy from Vault
 * @return
 */
@Override
public Optional<Economy> getEconomy() {
    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
    if (economyProvider != null) {
        return Optional.of(economyProvider.getProvider());
    }
    return Optional.absent();
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }

    RegisteredServiceProvider<Economy> provider = getServer().getServicesManager().getRegistration(Economy.class);
    if (provider == null) {
        return false;
    }

    economy = provider.getProvider();
    return economy != null;
}
 

public McPrisonVariables(ReplacerAPI replaceManager, Plugin plugin) throws UnsupportedPluginException {
    super(replaceManager, plugin);

    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServicesManager().getRegistration(Economy.class);
    if (economyProvider == null) {
        throw new UnsupportedPluginException("Couldn't find an economy plugin");
    } else {
        eco = economyProvider.getProvider();
    }
}
 

public VaultVariables(ReplacerAPI replaceManager, Plugin plugin) throws UnsupportedPluginException {
    super(replaceManager, plugin);

    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServicesManager().getRegistration(Economy.class);
    if (economyProvider == null) {
        //check if an economy plugin is installed otherwise it would throw a exception if the want to replace
        throw new UnsupportedPluginException("Cannot find an economy plugin");
    } else {
        economy = economyProvider.getProvider();
    }
}
 

/**
 * @return Economy returns Economy instance otherwise null if none found
 */
public Economy getEcon() {
    if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
        return null;
    }
    RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl
            .vault.economy.Economy.class);
    if (rsp != null) {
        return rsp.getProvider();
    }
    return null;
}
 

/**
 * vault-chatをロードする
 * @param plugin vaultのプラグインインスタンス
 * @return ロードしたブリッジのインスタンス
 */
public static VaultChatBridge load(Plugin plugin) {

    RegisteredServiceProvider<Chat> chatProvider =
            Bukkit.getServicesManager().getRegistration(Chat.class);
    if ( chatProvider != null ) {
        VaultChatBridge bridge = new VaultChatBridge();
        bridge.chatPlugin = chatProvider.getProvider();
        return bridge;
    }

    return null;
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null)
        return false;
    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null)
        return false;
    econ = rsp.getProvider();
    return econ != null;
}
 

/**
 * Get the Vault permissions provider.
 * @return Vault permissions provider
 */
public net.milkbowl.vault.permission.Permission getPermissionProvider() {
	RegisteredServiceProvider<net.milkbowl.vault.permission.Permission> permissionProvider = getServer().getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
	if (permissionProvider == null || permissionProvider.getProvider() == null) {
		return null;
	}
	return permissionProvider.getProvider();
}
 

private Optional<Economy> setupEconomy() {
    RegisteredServiceProvider<Economy> rsp =
        plugin.getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp != null) {
        economy = rsp.getProvider();
        return Optional.of(economy);
    }

    return Optional.empty();
}
 

private Optional<Permission> setupPermission() {
    RegisteredServiceProvider<Permission> rsp =
        plugin.getServer().getServicesManager().getRegistration(Permission.class);
    if (rsp != null) {
        permission = rsp.getProvider();
        return Optional.of(permission);
    }

    return Optional.empty();
}
 

/**
 * Setups economy
 */
public void setupEconomy() {
	RegisteredServiceProvider<Economy> rsp = Bukkit.getServicesManager().getRegistration(Economy.class);
	Validate.notNull(rsp, "Could not find the Economy provider");
	economy = rsp.getProvider();
	Validate.notNull(economy);
}
 

public PlayerInteractListener(PetMaster petMaster) {
	this.plugin = petMaster;
	version = Integer.parseInt(PackageType.getServerVersion().split("_")[1]);
	// Try to retrieve an Economy instance from Vault.
	if (Bukkit.getServer().getPluginManager().getPlugin("Vault") != null) {
		RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager()
				.getRegistration(Economy.class);
		if (rsp != null) {
			economy = rsp.getProvider();
		}
	}
}
 

/**
 * Sets up the economy of Vault
 * @return Whether an economy plugin has been registered
 */
private boolean setupEconomy() {
    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }
    econ = rsp.getProvider();
    return econ != null;
}
 

private boolean setupEconomy() {
	if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
           return false;
       }
       RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
       if (rsp == null) {
           return false;
       }
       econ = rsp.getProvider();
       return econ != null;
}
 

private boolean setupEconomy() {
	if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
           return false;
       }
       RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
       if (rsp == null) {
           return false;
       }
       econ = rsp.getProvider();
       return econ != null;
}
 

public VaultUtil() {
    final RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
    if (permissionProvider != null) {
        this.permission = permissionProvider.getProvider();
    } else {
        this.permission = null;
    }
}
 

/**
 * Sets up the vault economy.
 *
 * @return True if the economy was set up, false otherwise.
 */
private boolean setupEconomy() {
	RegisteredServiceProvider<net.milkbowl.vault.economy.Economy> economyProvider = getServer().getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
	if (economyProvider != null) {
		economy = economyProvider.getProvider();
	}
	
	return economy != null;
}
 

public boolean hasPermission(OfflinePlayer offlinePlayer, String permNode) {
    RegisteredServiceProvider<Permission> rsp = this.plugin.getServer().getServicesManager().getRegistration(Permission.class);

    if ((offlinePlayer == null) || (offlinePlayer.getUniqueId() == null) || Strings.isNullOrEmpty(offlinePlayer.getName())) {
        return false;
    }

    return (rsp != null) && rsp.getProvider().playerHas(null, offlinePlayer, permNode);
}
 

public static String[] getGroups() {
    if (!PluginUtil.pluginHookIsEnabled("vault")) return new String[] {};

    try {
        RegisteredServiceProvider<?> service = Bukkit.getServer().getServicesManager().getRegistration(Class.forName("net.milkbowl.vault.permission.Permission"));
        if (service == null) return new String[] {};

        Method getGroupsMethod = service.getProvider().getClass().getMethod("getGroups");
        return (String[]) getGroupsMethod.invoke(service.getProvider());
    } catch (Exception ignored) { }
    return new String[] {};
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }
    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }

    econ = rsp.getProvider();
    return true;
}