Java License类代码示例

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Override
public License getLicense(String deviceType, String languageCode) throws LicenseManagementException {
    try {
        String licenseConfigPath =
                PATH_MOBILE_PLUGIN_CONF_DIR + File.separator + deviceType + File.separator + "license.xml";
        File licenseConfig = new File(licenseConfigPath);

        if (!licenseConfig.exists()) {
            throw new LicenseManagementException(
                    "License file not found in the path for the device type " + deviceType);
        }
        JAXBContext context = JAXBContext.newInstance(License.class);
        Unmarshaller unmarshaller = context.createUnmarshaller();
        return (License) unmarshaller.unmarshal(licenseConfig);

    } catch (JAXBException e) {
        throw new LicenseManagementException("Error occurred while un-marshalling license configuration " +
                "used for '" + deviceType + "' platform from file system", e);
    }
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
private License populateLicense(GenericArtifact artifact) throws GovernanceException, ParseException {
    License license = new License();
    license.setName(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.NAME));
    license.setProvider(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.PROVIDER));
    license.setVersion(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.VERSION));
    license.setLanguage(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.LANGUAGE));
    license.setText(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.TEXT));

    DateFormat format = new SimpleDateFormat("dd-mm-yyyy", Locale.ENGLISH);
    String validFrom = artifact.getAttribute(DeviceManagementConstants.LicenseProperties.VALID_FROM);
    if (validFrom != null && !validFrom.isEmpty()) {
        license.setValidFrom(format.parse(validFrom));
    }
    String validTo = artifact.getAttribute(DeviceManagementConstants.LicenseProperties.VALID_TO);
    if (validTo != null && !validTo.isEmpty()) {
        license.setValidFrom(format.parse(validTo));
    }
    return license;
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Override
public boolean addLicense(String deviceType, License license) throws LicenseManagementException {
    GenericArtifactManager artifactManager =
            GenericArtifactManagerFactory.getTenantAwareGovernanceArtifactManager();
    try {
        GenericArtifact artifact =
                artifactManager.newGovernanceArtifact(new QName("http://www.wso2.com",
                        DeviceManagementConstants.LicenseProperties.LICENSE_REGISTRY_KEY));
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.NAME, license.getName());
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.VERSION, license.getVersion());
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.PROVIDER, license.getProvider());
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.LANGUAGE, license.getLanguage());
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.TEXT, license.getText());
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.VALID_TO,
                license.getValidTo().toString());
        artifact.setAttribute(DeviceManagementConstants.LicenseProperties.VALID_FROM,
                license.getValidFrom().toString());
        artifactManager.addGenericArtifact(artifact);
        return true;
    } catch (GovernanceException e) {
        throw new LicenseManagementException("Error occurred while adding license for device type " +
                deviceType + "'", e);
    }
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Test (description = "This test case tests the addition and retrieval of the license")
public void testGetLicense () throws LicenseManagementException {
    License license = arduinoDeviceTypeManagerService.getDeviceManager().getLicense("en_Us");
    Assert.assertEquals(license.getText(), arduinoDeviceTypeConfiguration.getLicense().getText(),
            "The retrieved" + " license is different from added license");
    license.setLanguage("eu");
    license.setText("This is a EU License");
    arduinoDeviceTypeManagerService.getDeviceManager().addLicense(license);
    License newLicense = arduinoDeviceTypeManagerService.getDeviceManager().getLicense("eu");
    Assert.assertEquals(newLicense.getText(), license.getText(),
            "The retrieved license is different from added license");
    Assert.assertNull(arduinoDeviceTypeManagerService.getDeviceManager().getLicense("tn"),
            "License is retrieved for a non-existing language code");
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Test(description = "This test cases tests the registry based license addition")
public void testAddRegistryBasedLicense() throws LicenseManagementException {
    String newLicenseString = "New License";
    License fileBasedLicense = fileSystemBasedLicenseManager.getLicense(Utils.TEST_STRING, "en_US");
    RegistryBasedLicenseManager registryBasedLicenseManager = new RegistryBasedLicenseManager();
    registryBasedLicenseManager.addLicense(Utils.TEST_STRING, fileBasedLicense);
    Assert.assertEquals(fileBasedLicense.getText(),
            registryBasedLicenseManager.getLicense(Utils.TEST_STRING, "en_US").getText(),
            "Registry license addition failed");
    fileBasedLicense.setText(newLicenseString);
    registryBasedLicenseManager.addLicense(Utils.TEST_STRING, fileBasedLicense);
    Assert.assertEquals(registryBasedLicenseManager.getLicense(Utils.TEST_STRING, "en_US").getText(),
            newLicenseString, "Registry license update failed");
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Override
public License getLicense(String languageCode) throws LicenseManagementException {
    License testLicense = new License();
    testLicense.setText("This is a dummy license for test device type.");
    testLicense.setLanguage("ENG");
    return testLicense;
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Test
public void addLicense() throws DeviceManagementException {
    License license = new License();
    license.setLanguage("ENG");
    license.setName("RANDON_DEVICE_LICENSE");
    deviceMgtService.addLicense(DEVICE_TYPE, license);
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
private License populateLicense(GenericArtifact artifact) throws GovernanceException, ParseException {
    License license = new License();
    license.setName(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.NAME));
    license.setProvider(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.PROVIDER));
    license.setVersion(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.VERSION));
    license.setLanguage(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.LANGUAGE));
    license.setText(artifact.getAttribute(DeviceManagementConstants.LicenseProperties.TEXT));
    license.setValidFrom(format.parse(artifact.getAttribute(
            DeviceManagementConstants.LicenseProperties.VALID_FROM)));
    license.setValidTo(format.parse(artifact.getAttribute(
            DeviceManagementConstants.LicenseProperties.VALID_TO)));
    return license;
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
private void setupDefaultLicenses(LicenseConfig licenseConfig)
        throws LicenseManagementException {
    LicenseManager licenseManager = DeviceManagementDataHolder.getInstance().getLicenseManager();
    for (License license : licenseConfig.getLicenses()) {
        License extLicense = licenseManager.getLicense(license.getName(), license.getLanguage());
        if (extLicense == null) {
            licenseManager.addLicense(license.getName(), license);
        }
    }
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
public License getLicense() {
    return license;
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
public void setLicense(License license) {
    this.license = license;
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Override
public void addLicense(String deviceType, License license) throws LicenseManagementException {
    throw new UnsupportedOperationException("'addLicense' method is not supported in " +
            "FileSystemBasedLicenseManager");
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Override
public License getLicense(String languageCode) throws LicenseManagementException {
    return licenseManager.getLicense(deviceType, languageCode);
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
@Override
public void addLicense(License license) throws LicenseManagementException {
    licenseManager.addLicense(deviceType, license);
}
 

import org.wso2.carbon.device.mgt.common.license.mgt.License; //导入依赖的package包/类
/**
 * To create a sample device type meta defintion.
 * @throws SAXException SAX Exception.
 * @throws JAXBException JAXB Exception.
 * @throws ParserConfigurationException ParserConfiguration Exception.
 * @throws DeviceTypeConfigurationException DeviceTypeConfiguration Exception.
 * @throws IOException IO Exception.
 */
private void createSampleDeviceTypeMetaDefinition()
        throws SAXException, JAXBException, ParserConfigurationException, DeviceTypeConfigurationException,
        IOException {
    ClassLoader classLoader = getClass().getClassLoader();
    URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "android_sense.xml");
    File androidSenseConfiguration = null;

    if (resourceUrl != null) {
        androidSenseConfiguration = new File(resourceUrl.getFile());
    }
    DeviceTypeConfiguration androidSenseDeviceTypeConfiguration = Utils
            .getDeviceTypeConfiguration(androidSenseConfiguration);
    PushNotificationProvider pushNotificationProvider = androidSenseDeviceTypeConfiguration
            .getPushNotificationProvider();
    PushNotificationConfig pushNotificationConfig = new PushNotificationConfig(pushNotificationProvider.getType(),
            pushNotificationProvider.isScheduled(), null);
    org.wso2.carbon.device.mgt.extensions.device.type.template.config.License license =
            androidSenseDeviceTypeConfiguration.getLicense();
    License androidSenseLicense = new License();
    androidSenseLicense.setText(license.getText());
    androidSenseLicense.setLanguage(license.getLanguage());

    List<Feature> configurationFeatues = androidSenseDeviceTypeConfiguration.getFeatures().getFeature();
    List<org.wso2.carbon.device.mgt.common.Feature> features = new ArrayList<>();

    for (Feature feature : configurationFeatues) {
        org.wso2.carbon.device.mgt.common.Feature commonFeature = new org.wso2.carbon.device.mgt.common.Feature();
        commonFeature.setCode(feature.getCode());
        commonFeature.setDescription(feature.getDescription());
        commonFeature.setName(feature.getName());
        org.wso2.carbon.device.mgt.common.Feature.MetadataEntry metadataEntry = new org.wso2.carbon.device.mgt
                .common.Feature.MetadataEntry();
        metadataEntry.setId(1);
        metadataEntry.setValue(Utils.TEST_STRING);
        List<org.wso2.carbon.device.mgt.common.Feature.MetadataEntry> metadataEntries = new ArrayList<>();
        metadataEntries.add(metadataEntry);
        commonFeature.setMetadataEntries(metadataEntries);
        features.add(commonFeature);
    }

    deviceTypeMetaDefinition = new DeviceTypeMetaDefinition();
    deviceTypeMetaDefinition.setPushNotificationConfig(pushNotificationConfig);
    deviceTypeMetaDefinition.setDescription("This is android_sense");
    deviceTypeMetaDefinition.setClaimable(true);
    deviceTypeMetaDefinition.setLicense(androidSenseLicense);
    deviceTypeMetaDefinition.setFeatures(features);
}