community/device-mgt-plugins
1
0
Fork 0
mirror of https://repository.entgra.net/community/device-mgt-plugins.git synced 2025-09-16 23:42:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #181 from hasuniea/master

Browse Source 
Refactored code issues
This commit is contained in:
Hasunie 2016-05-12 21:49:45 +05:30
commit cb73e24036
27 changed files with 1490 additions and 644 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/pom.xml
View File

@ -172,6 +172,12 @@
<scope>provided</scope>
</dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>

161
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/ConfigurationMgtService.java
View File

@ -1,161 +0,0 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationEntry;
import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration;
import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.AndroidConstants;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
/**
* Android Platform Configuration REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@WebService
@Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" })
public class ConfigurationMgtService {
private static Log log = LogFactory.getLog(ConfigurationMgtService.class);
@POST
public Message configureSettings(TenantConfiguration configuration)
throws AndroidAgentException {
Message responseMsg = new Message();
String msg;
ConfigurationEntry licenseEntry = null;
try {
configuration.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
List<ConfigurationEntry> configs = configuration.getConfiguration();
for(ConfigurationEntry entry : configs){
if(AndroidConstants.TenantConfigProperties.LICENSE_KEY.equals(entry.getName())){
License license = new License();
license.setName(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
license.setLanguage(AndroidConstants.TenantConfigProperties.LANGUAGE_US);
license.setVersion("1.0.0");
license.setText(entry.getValue().toString());
AndroidAPIUtils.getDeviceManagementService().addLicense(DeviceManagementConstants.
MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID, license);
licenseEntry = entry;
break;
}
}
if(licenseEntry != null) {
configs.remove(licenseEntry);
}
configuration.setConfiguration(configs);
AndroidAPIUtils.getDeviceManagementService().saveConfiguration(configuration);
Response.status(Response.Status.CREATED);
responseMsg.setResponseMessage("Android platform configuration saved successfully.");
responseMsg.setResponseCode(Response.Status.CREATED.toString());
} catch (DeviceManagementException e) {
msg = "Error occurred while configuring the android platform";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@GET
public TenantConfiguration getConfiguration() throws AndroidAgentException {
String msg;
TenantConfiguration tenantConfiguration;
List<ConfigurationEntry> configs;
try {
tenantConfiguration = AndroidAPIUtils.getDeviceManagementService().
getConfiguration(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
if(tenantConfiguration != null) {
configs = tenantConfiguration.getConfiguration();
} else {
tenantConfiguration = new TenantConfiguration();
configs = new ArrayList<ConfigurationEntry>();
}
ConfigurationEntry entry = new ConfigurationEntry();
License license = AndroidAPIUtils.getDeviceManagementService().getLicense(
DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID, AndroidConstants.
TenantConfigProperties.LANGUAGE_US);
if(license != null && configs != null) {
entry.setContentType(AndroidConstants.TenantConfigProperties.CONTENT_TYPE_TEXT);
entry.setName(AndroidConstants.TenantConfigProperties.LICENSE_KEY);
entry.setValue(license.getText());
configs.add(entry);
tenantConfiguration.setConfiguration(configs);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while retrieving the Android tenant configuration";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return tenantConfiguration;
}
@PUT
public Message updateConfiguration(TenantConfiguration configuration) throws AndroidAgentException {
String msg;
Message responseMsg = new Message();
ConfigurationEntry licenseEntry = null;
try {
configuration.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
List<ConfigurationEntry> configs = configuration.getConfiguration();
for(ConfigurationEntry entry : configs){
if(AndroidConstants.TenantConfigProperties.LICENSE_KEY.equals(entry.getName())){
License license = new License();
license.setName(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
license.setLanguage(AndroidConstants.TenantConfigProperties.LANGUAGE_US);
license.setVersion("1.0.0");
license.setText(entry.getValue().toString());
AndroidAPIUtils.getDeviceManagementService().addLicense(DeviceManagementConstants.
MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID, license);
licenseEntry = entry;
}
}
if(licenseEntry != null) {
configs.remove(licenseEntry);
}
configuration.setConfiguration(configs);
AndroidAPIUtils.getDeviceManagementService().saveConfiguration(configuration);
Response.status(Response.Status.ACCEPTED);
responseMsg.setResponseMessage("Android platform configuration has updated successfully.");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
} catch (DeviceManagementException e) {
msg = "Error occurred while modifying configuration settings of Android platform";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
}

183
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/DeviceManagementService.java
View File

@ -1,183 +0,0 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.app.mgt.Application;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManagementException;
import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Android Device Management REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@WebService
@Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" })
public class DeviceManagementService {
private static Log log = LogFactory.getLog(DeviceManagementService.class);
/**
* Get all devices.Returns list of Android devices registered in MDM.
*
* @return Device List
* @throws org.wso2.carbon.mdm.services.android.exception.AndroidAgentException
*/
@GET
public List<org.wso2.carbon.device.mgt.common.Device> getAllDevices()
throws AndroidAgentException {
String msg;
List<org.wso2.carbon.device.mgt.common.Device> devices;
try {
devices = AndroidAPIUtils.getDeviceManagementService().
getAllDevices(DeviceManagementConstants.MobileDeviceTypes.
MOBILE_DEVICE_TYPE_ANDROID);
} catch (DeviceManagementException e) {
msg = "Error occurred while fetching the device list.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return devices;
}
/**
* Fetch Android device details of a given device Id.
*
* @param id Device Id
* @return Device
* @throws org.wso2.carbon.mdm.services.android.exception.AndroidAgentException
*/
@GET
@Path("{id}")
public org.wso2.carbon.device.mgt.common.Device getDevice(@PathParam("id") String id)
throws AndroidAgentException {
String msg;
org.wso2.carbon.device.mgt.common.Device device;
try {
DeviceIdentifier deviceIdentifier = AndroidAPIUtils.convertToDeviceIdentifierObject(id);
device = AndroidAPIUtils.getDeviceManagementService().getDevice(deviceIdentifier);
if (device == null) {
Response.status(Response.Status.NOT_FOUND);
}
} catch (DeviceManagementException deviceMgtEx) {
msg = "Error occurred while fetching the device information.";
log.error(msg, deviceMgtEx);
throw new AndroidAgentException(msg, deviceMgtEx);
}
return device;
}
/**
* Update Android device details of given device id.
*
* @param id Device Id
* @param device Device Details
* @return Message
* @throws AndroidAgentException
*/
@PUT
@Path("{id}")
public Message updateDevice(@PathParam("id") String id, Device device)
throws AndroidAgentException {
String msg;
Message responseMessage = new Message();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(id);
deviceIdentifier
.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
boolean result;
try {
device.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
result = AndroidAPIUtils.getDeviceManagementService()
.updateDeviceInfo(deviceIdentifier, device);
if (result) {
Response.status(Response.Status.ACCEPTED);
responseMessage.setResponseMessage("Device information has modified successfully.");
} else {
Response.status(Response.Status.NOT_MODIFIED);
responseMessage.setResponseMessage("Device not found for the update.");
}
} catch (DeviceManagementException e) {
msg = "Error occurred while modifying the device information.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMessage;
}
@POST
@Path("appList/{id}")
public Message updateApplicationList(@PathParam("id") String id, List<Application> applications)
throws
AndroidAgentException {
Message responseMessage = new Message();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(id);
deviceIdentifier.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
try {
AndroidAPIUtils.getApplicationManagerService().
updateApplicationListInstalledInDevice(deviceIdentifier, applications);
Response.status(Response.Status.ACCEPTED);
responseMessage.setResponseMessage("Device information has modified successfully.");
} catch (ApplicationManagementException e) {
String msg = "Error occurred while modifying the application list.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMessage;
}
@GET
@Path("license")
@Produces("text/html")
public String getLicense() throws AndroidAgentException {
License license;
try {
license =
AndroidAPIUtils.getDeviceManagementService().getLicense(
DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID,
DeviceManagementConstants.LanguageCodes.LANGUAGE_CODE_ENGLISH_US);
} catch (DeviceManagementException e) {
String msg = "Error occurred while retrieving the license configured for Android device enrolment";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return (license == null) ? null : license.getText();
}
}

153
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/EnrollmentService.java
View File

@ -1,153 +0,0 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
/**
* Android Device Enrollment REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@WebService
@Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" })
public class EnrollmentService {
private static Log log = LogFactory.getLog(EnrollmentService.class);
@POST
public Message enrollDevice(org.wso2.carbon.device.mgt.common.Device device)
throws AndroidAgentException {
Message responseMsg = new Message();
String msg;
try {
device.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
device.getEnrolmentInfo().setOwner(AndroidAPIUtils.getAuthenticatedUser());
boolean status = AndroidAPIUtils.getDeviceManagementService().enrollDevice(device);
if (status) {
Response.status(Response.Status.CREATED);
responseMsg.setResponseMessage("Device enrollment succeeded.");
responseMsg.setResponseCode(Response.Status.CREATED.toString());
} else {
Response.status(Response.Status.INTERNAL_SERVER_ERROR);
responseMsg.setResponseMessage("Device enrollment failed.");
responseMsg.setResponseCode(Response.Status.INTERNAL_SERVER_ERROR.toString());
}
} catch (DeviceManagementException e) {
msg = "Error occurred while enrolling the device";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@GET
@Path("{deviceId}")
public Message isEnrolled(@PathParam("deviceId") String id) throws AndroidAgentException {
String msg;
boolean result;
Message responseMsg = new Message();
DeviceIdentifier deviceIdentifier = AndroidAPIUtils.convertToDeviceIdentifierObject(id);
try {
result = AndroidAPIUtils.getDeviceManagementService().isEnrolled(deviceIdentifier);
if (result) {
responseMsg.setResponseMessage("Device has already enrolled");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
Response.status(Response.Status.ACCEPTED);
} else {
responseMsg.setResponseMessage("Device not found");
responseMsg.setResponseCode(Response.Status.NOT_FOUND.toString());
Response.status(Response.Status.NOT_FOUND);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while enrollment of the device.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@PUT
@Path("{deviceId}")
public Message modifyEnrollment(@PathParam("deviceId") String id,
org.wso2.carbon.device.mgt.common.Device device)
throws AndroidAgentException {
String msg;
boolean result;
Message responseMsg = new Message();
try {
device.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
result = AndroidAPIUtils.getDeviceManagementService().modifyEnrollment(device);
if (result) {
responseMsg.setResponseMessage("Device enrollment has updated successfully");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
Response.status(Response.Status.ACCEPTED);
} else {
responseMsg.setResponseMessage("Device not found for enrollment");
responseMsg.setResponseCode(Response.Status.NOT_MODIFIED.toString());
Response.status(Response.Status.NOT_MODIFIED);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while modifying enrollment of the device";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@DELETE
@Path("{deviceId}")
public Message disEnrollDevice(@PathParam("deviceId") String id) throws AndroidAgentException {
Message responseMsg = new Message();
boolean result;
String msg;
DeviceIdentifier deviceIdentifier = AndroidAPIUtils.convertToDeviceIdentifierObject(id);
try {
result = AndroidAPIUtils.getDeviceManagementService().disenrollDevice(deviceIdentifier);
if (result) {
responseMsg.setResponseMessage("Device has removed successfully");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
Response.status(Response.Status.ACCEPTED);
} else {
responseMsg.setResponseMessage("Device not found");
responseMsg.setResponseCode(Response.Status.NOT_FOUND.toString());
Response.status(Response.Status.NOT_FOUND);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while dis enrolling the device";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
}

10
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/bean/ApplicationInstallation.java
View File

@ -18,15 +18,25 @@
package org.wso2.carbon.mdm.services.android.bean;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
* This class represents the information of install application operation.
*/
@ApiModel(value = "ApplicationInstallation",
description = "This class carries all information related to install application")
public class ApplicationInstallation extends AndroidOperation implements Serializable {
@ApiModelProperty(name = "appIdentifier", value = "DeviceIdentifier", required = true)
private String appIdentifier;
@ApiModelProperty(name = "type", value = "Application type(Enterprise/Web/public)", required = true)
private String type;
@ApiModelProperty(name = "url", value = "Application URL", required = true)
private String url;
public String getAppIdentifier() {

8
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/bean/wrapper/ApplicationInstallationBeanWrapper.java
View File

@ -17,6 +17,8 @@
*/
package org.wso2.carbon.mdm.services.android.bean.wrapper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import org.wso2.carbon.mdm.services.android.bean.ApplicationInstallation;
import java.util.List;
@ -24,9 +26,15 @@ import java.util.List;
/**
* This class is used to wrap the InstallApplication bean with devices.
*/
@ApiModel(value = "ApplicationInstallationBeanWrapper",
description = "This class carries all information related to a InstallApplication")
public class ApplicationInstallationBeanWrapper {
@ApiModelProperty(name = "deviceIDs", value = "List of Devices", required = true)
private List<String> deviceIDs;
@ApiModelProperty(name = "operation", value = "App Installation property", required = true)
private ApplicationInstallation operation;
public List<String> getDeviceIDs() {

7
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/bean/wrapper/ApplicationUninstallationBeanWrapper.java
View File

@ -17,6 +17,8 @@
*/
package org.wso2.carbon.mdm.services.android.bean.wrapper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import org.wso2.carbon.mdm.services.android.bean.ApplicationUninstallation;
import java.util.List;
@ -24,9 +26,14 @@ import java.util.List;
/**
* This class is used to wrap the UninstallApplication bean with devices.
*/
@ApiModel(value = "ApplicationUninstallationBeanWrapper",
description = "This class carries all information related to Uninstall Application")
public class ApplicationUninstallationBeanWrapper {
@ApiModelProperty(name = "deviceIDs", value = "List of device Ids", required = true)
private List<String> deviceIDs;
@ApiModelProperty(name = "operation", value = "Name of the device", required = true)
private ApplicationUninstallation operation;
public List<String> getDeviceIDs() {

81
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/configuration/ConfigurationMgtService.java Normal file
View File

@ -0,0 +1,81 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.configuration;
import io.swagger.annotations.*;
import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
/**
* Android Platform Configuration REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@Api(value = "ConfigurationMgtService")
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public interface ConfigurationMgtService {
@POST
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Configuring Android Platform Settings",
notes = "Configure the Android platform settings using this REST API"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Android platform configuration saved successfully"),
@ApiResponse(code = 500, message = "Internal Server Error")
})
Message configureSettings(@ApiParam(name = "configuration", value = "AndroidPlatformConfiguration")
TenantConfiguration configuration) throws AndroidAgentException;
@GET
@ApiOperation(
httpMethod = "GET",
value = "Getting Android Platform Configurations",
notes = "Get the Android platform configuration details using this REST API",
response = TenantConfiguration.class
)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Get Android Configurations"),
@ApiResponse(code = 500, message = "Server Error")
})
TenantConfiguration getConfiguration() throws AndroidAgentException;
@PUT
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "PUT",
value = "Updating Android Platform Configurations",
notes = "Update the Android platform configurations using this REST API"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Error occurred while modifying configuration settings of " +
"Android platform")
})
Message updateConfiguration(TenantConfiguration configuration) throws AndroidAgentException;
}

162
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/configuration/impl/ConfigurationMgtServiceImpl.java Normal file
View File

@ -0,0 +1,162 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.configuration.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationEntry;
import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration;
import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.mdm.services.android.services.configuration.ConfigurationMgtService;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.AndroidConstants;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
/**
* Android Platform Configuration REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public class ConfigurationMgtServiceImpl implements ConfigurationMgtService {
private static Log log = LogFactory.getLog(ConfigurationMgtServiceImpl.class);
@POST
public Message configureSettings(TenantConfiguration configuration)
throws AndroidAgentException {
Message responseMsg = new Message();
String msg;
ConfigurationEntry licenseEntry = null;
try {
configuration.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
List<ConfigurationEntry> configs = configuration.getConfiguration();
for (ConfigurationEntry entry : configs) {
if (AndroidConstants.TenantConfigProperties.LICENSE_KEY.equals(entry.getName())) {
License license = new License();
license.setName(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
license.setLanguage(AndroidConstants.TenantConfigProperties.LANGUAGE_US);
license.setVersion("1.0.0");
license.setText(entry.getValue().toString());
AndroidAPIUtils.getDeviceManagementService().addLicense(DeviceManagementConstants.
MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID, license);
licenseEntry = entry;
break;
}
}
if (licenseEntry != null) {
configs.remove(licenseEntry);
}
configuration.setConfiguration(configs);
AndroidAPIUtils.getDeviceManagementService().saveConfiguration(configuration);
Response.status(Response.Status.CREATED);
responseMsg.setResponseMessage("Android platform configuration saved successfully.");
responseMsg.setResponseCode(Response.Status.CREATED.toString());
} catch (DeviceManagementException e) {
msg = "Error occurred while configuring the android platform";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@GET
public TenantConfiguration getConfiguration() throws AndroidAgentException {
String msg;
TenantConfiguration tenantConfiguration;
List<ConfigurationEntry> configs;
try {
tenantConfiguration = AndroidAPIUtils.getDeviceManagementService().
getConfiguration(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
if (tenantConfiguration != null) {
configs = tenantConfiguration.getConfiguration();
} else {
tenantConfiguration = new TenantConfiguration();
configs = new ArrayList<ConfigurationEntry>();
}
ConfigurationEntry entry = new ConfigurationEntry();
License license = AndroidAPIUtils.getDeviceManagementService().getLicense(
DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID, AndroidConstants.
TenantConfigProperties.LANGUAGE_US);
if (license != null && configs != null) {
entry.setContentType(AndroidConstants.TenantConfigProperties.CONTENT_TYPE_TEXT);
entry.setName(AndroidConstants.TenantConfigProperties.LICENSE_KEY);
entry.setValue(license.getText());
configs.add(entry);
tenantConfiguration.setConfiguration(configs);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while retrieving the Android tenant configuration";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return tenantConfiguration;
}
@PUT
public Message updateConfiguration(TenantConfiguration configuration) throws AndroidAgentException {
String msg;
Message responseMsg = new Message();
ConfigurationEntry licenseEntry = null;
try {
configuration.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
List<ConfigurationEntry> configs = configuration.getConfiguration();
for (ConfigurationEntry entry : configs) {
if (AndroidConstants.TenantConfigProperties.LICENSE_KEY.equals(entry.getName())) {
License license = new License();
license.setName(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
license.setLanguage(AndroidConstants.TenantConfigProperties.LANGUAGE_US);
license.setVersion("1.0.0");
license.setText(entry.getValue().toString());
AndroidAPIUtils.getDeviceManagementService().addLicense(DeviceManagementConstants.
MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID, license);
licenseEntry = entry;
}
}
if (licenseEntry != null) {
configs.remove(licenseEntry);
}
configuration.setConfiguration(configs);
AndroidAPIUtils.getDeviceManagementService().saveConfiguration(configuration);
Response.status(Response.Status.ACCEPTED);
responseMsg.setResponseMessage("Android platform configuration has updated successfully.");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
} catch (DeviceManagementException e) {
msg = "Error occurred while modifying configuration settings of Android platform";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
}

147
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/devicemgt/DeviceManagementService.java Normal file
View File

@ -0,0 +1,147 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.devicemgt;
import io.swagger.annotations.*;
import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.app.mgt.Application;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.List;
/**
* Android Device Management REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@Api(value = "DeviceManagementService")
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public interface DeviceManagementService {
/**
* Get all devices.Returns list of Android devices registered in MDM.
*
* @return Device List
* @throws org.wso2.carbon.mdm.services.android.exception.AndroidAgentException
*/
@GET
@ApiOperation(
produces = MediaType.APPLICATION_JSON,
httpMethod = "GET",
value = "Getting Details of All Android Devices",
notes = "Use this REST API to retrieve the details " +
"(e.g., the Android device type, serial number, International Mobile Station Equipment Identity " +
"(IMEI), owner, version, model etc.) of all Android devices that are registered with WSO2 EMM.",
response = Device.class,
responseContainer = "List"
)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "List of Devices"),
@ApiResponse(code = 500, message = "Error occurred while fetching the device list")
})
List<org.wso2.carbon.device.mgt.common.Device> getAllDevices() throws AndroidAgentException;
/**
* Fetch Android device details of a given device Id.
*
* @param id Device Id
* @return Device
* @throws org.wso2.carbon.mdm.services.android.exception.AndroidAgentException
*/
@GET
@Path("{id}")
@ApiOperation(
produces = MediaType.APPLICATION_JSON,
httpMethod = "GET",
value = "Getting Details of an Android Device",
notes = "Use this REST API to retrieve the details " +
"(e.g., the Android device type, serial number, International Mobile Station Equipment Identity " +
"(IMEI), owner, version, model etc.) of a specific Android device that is registered with WSO2 EMM",
response = Device.class
)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Information of the given device"),
@ApiResponse(code = 500, message = "Error occurred while fetching the device information")
})
org.wso2.carbon.device.mgt.common.Device getDevice(@ApiParam(name = "id", value = "deviceIdentifier")
@PathParam("id") String id) throws AndroidAgentException;
/**
* Update Android device details of given device id.
*
* @param id Device Id
* @param device Device Details
* @return Message
* @throws AndroidAgentException
*/
@PUT
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "PUT",
value = "Updating the Details of an Android Device",
notes = "Use this REST API to update the details of an Android device"
)
@ApiResponses(value = {
@ApiResponse(code = 202, message = "The device enrollment details has been updated successfully"),
@ApiResponse(code = 500, message = "Error occurred while modifying the device information"),
@ApiResponse(code = 304, message = "Device not found for the update")
})
@Path("{id}")
Message updateDevice(@ApiParam(name = "id", value = "deviceIdentifier")
@PathParam("id") String id, @ApiParam(name = "device", value = "deviceIdentifier")
Device device) throws AndroidAgentException;
@POST
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Updating an ApplicationList",
notes = "Update application list in server side."
)
@ApiResponses(value = {
@ApiResponse(code = 202, message = "Device information has modified successfully"),
@ApiResponse(code = 500, message = "Error occurred while modifying the application list")
})
Message updateApplicationList(@ApiParam(name = "id", value = "deviceIdentifier") @PathParam("id") String id,
@ApiParam(name = "applications", value = "updatable applications")
List<Application> applications);
@GET
@Path("license")
@Produces("text/html")
@ApiOperation(
produces = MediaType.APPLICATION_JSON,
httpMethod = "GET",
value = "Getting the License Agreement for Android Device Registration",
notes = "Use this REST API to retrieve the license agreement that is used for the Android device " +
"registration process",
response = String.class)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Licence agreement"),
@ApiResponse(code = 500, message = "Error occurred while retrieving the license configured for Android " +
"device enrolment")})
String getLicense() throws AndroidAgentException;
}

184
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/devicemgt/impl/DeviceManagementServiceImpl.java Normal file
View File

@ -0,0 +1,184 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.devicemgt.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.app.mgt.Application;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManagementException;
import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Android Device Management REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public class DeviceManagementServiceImpl {
private static Log log = LogFactory.getLog(DeviceManagementServiceImpl.class);
/**
* Get all devices.Returns list of Android devices registered in MDM.
*
* @return Device List
* @throws AndroidAgentException
*/
@GET
public List<Device> getAllDevices()
throws AndroidAgentException {
String msg;
List<Device> devices;
try {
devices = AndroidAPIUtils.getDeviceManagementService().
getAllDevices(DeviceManagementConstants.MobileDeviceTypes.
MOBILE_DEVICE_TYPE_ANDROID);
} catch (DeviceManagementException e) {
msg = "Error occurred while fetching the device list.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return devices;
}
/**
* Fetch Android device details of a given device Id.
*
* @param id Device Id
* @return Device
* @throws AndroidAgentException
*/
@GET
@Path("{id}")
public Device getDevice(@PathParam("id") String id)
throws AndroidAgentException {
String msg;
Device device;
try {
DeviceIdentifier deviceIdentifier = AndroidAPIUtils.convertToDeviceIdentifierObject(id);
device = AndroidAPIUtils.getDeviceManagementService().getDevice(deviceIdentifier);
if (device == null) {
Response.status(Response.Status.NOT_FOUND);
}
} catch (DeviceManagementException deviceMgtEx) {
msg = "Error occurred while fetching the device information.";
log.error(msg, deviceMgtEx);
throw new AndroidAgentException(msg, deviceMgtEx);
}
return device;
}
/**
* Update Android device details of given device id.
*
* @param id Device Id
* @param device Device Details
* @return Message
* @throws AndroidAgentException
*/
@PUT
@Path("{id}")
public Message updateDevice(@PathParam("id") String id, Device device)
throws AndroidAgentException {
String msg;
Message responseMessage = new Message();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(id);
deviceIdentifier
.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
boolean result;
try {
device.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
result = AndroidAPIUtils.getDeviceManagementService()
.updateDeviceInfo(deviceIdentifier, device);
if (result) {
Response.status(Response.Status.ACCEPTED);
responseMessage.setResponseMessage("Device information has modified successfully.");
} else {
Response.status(Response.Status.NOT_MODIFIED);
responseMessage.setResponseMessage("Device not found for the update.");
}
} catch (DeviceManagementException e) {
msg = "Error occurred while modifying the device information.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMessage;
}
@POST
@Path("appList/{id}")
public Message updateApplicationList(@PathParam("id") String id, List<Application> applications)
throws
AndroidAgentException {
Message responseMessage = new Message();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(id);
deviceIdentifier.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
try {
AndroidAPIUtils.getApplicationManagerService().
updateApplicationListInstalledInDevice(deviceIdentifier, applications);
Response.status(Response.Status.ACCEPTED);
responseMessage.setResponseMessage("Device information has modified successfully.");
} catch (ApplicationManagementException e) {
String msg = "Error occurred while modifying the application list.";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMessage;
}
@GET
@Path("license")
@Produces("text/html")
public String getLicense() throws AndroidAgentException {
License license;
try {
license =
AndroidAPIUtils.getDeviceManagementService().getLicense(
DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID,
DeviceManagementConstants.LanguageCodes.LANGUAGE_CODE_ENGLISH_US);
} catch (DeviceManagementException e) {
String msg = "Error occurred while retrieving the license configured for Android device enrolment";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return (license == null) ? null : license.getText();
}
}

99
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/enrollment/EnrollmentService.java Normal file
View File

@ -0,0 +1,99 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.enrollment;
import io.swagger.annotations.*;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
/**
* Android Device Enrollment REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@Api(value = "EnrollmentService")
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public interface EnrollmentService {
@POST
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Registering an Android Device",
notes = "When carrying out device registration via an Android device, you need to initially install" +
" an Android Agent on the device, before being able to register the device with WSO2 EMM. Instead," +
" you can use this REST API to register an Android device with WSO2 EMM, without having to install" +
" an Android Agent on the respective device"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Device enrollment succeeded"),
@ApiResponse(code = 500, message = "Device enrollment failed"),
})
Message enrollDevice(@ApiParam(name = "device", value = "Device Information to be enroll")
org.wso2.carbon.device.mgt.common.Device device) throws AndroidAgentException;
@GET
@Path("{deviceId}")
@ApiOperation(
httpMethod = "GET",
value = "Getting the Registration Status of an Android Device",
notes = "Use this REST API to retrieve the registration status of an Android device"
)
@ApiResponses(value = {
@ApiResponse(code = 202, message = "Device has already enrolled"),
@ApiResponse(code = 404, message = "Device not found")
})
Message isEnrolled(@ApiParam(name = "deviceId", value = "DeviceIdentifier") @PathParam("deviceId") String id)
throws AndroidAgentException;
@PUT
@Path("{deviceId}")
@ApiOperation(
httpMethod = "PUT",
value = "Updating the Registration Details of an Android Device",
notes = "Use this REST API to update the registration details of an Android device"
)
@ApiResponses(value = {
@ApiResponse(code = 202, message = "Device enrollment has updated successfully"),
@ApiResponse(code = 404, message = "Device not found for enrollment")
})
Message modifyEnrollment(@ApiParam(name = "deviceId", value = "DeviceIdentifier") @PathParam("deviceId") String id,
@ApiParam(name = "device", value = "Device information to be modify")
org.wso2.carbon.device.mgt.common.Device device)
throws AndroidAgentException;
@DELETE
@ApiOperation(
httpMethod = "DELETE",
value = "Un-registering an Android Device",
notes = "Use this REST API to unregister a specific Android device"
)
@ApiResponses(value = {
@ApiResponse(code = 202, message = "Device has removed successfully"),
@ApiResponse(code = 404, message = "Device not found")
})
@Path("{deviceId}")
Message disEnrollDevice(@ApiParam(name = "deviceId", value = "DeviceIdentifier") @PathParam("deviceId") String id)
throws AndroidAgentException;
}

158
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/enrollment/impl/EnrollmentServiceImpl.java Normal file
View File

@ -0,0 +1,158 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.enrollment.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.services.enrollment.EnrollmentService;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.Message;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
/**
* Android Device Enrollment REST-API implementation.
* All end points supports JSON, XMl with content negotiation.
*/
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public class EnrollmentServiceImpl implements EnrollmentService {
private static Log log = LogFactory.getLog(EnrollmentService.class);
@POST
public Message enrollDevice(org.wso2.carbon.device.mgt.common.Device device)
throws AndroidAgentException {
Message responseMsg = new Message();
String msg;
try {
device.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
device.getEnrolmentInfo().setOwner(AndroidAPIUtils.getAuthenticatedUser());
boolean status = AndroidAPIUtils.getDeviceManagementService().enrollDevice(device);
if (status) {
Response.status(Response.Status.CREATED);
responseMsg.setResponseMessage("Device enrollment succeeded.");
responseMsg.setResponseCode(Response.Status.CREATED.toString());
} else {
Response.status(Response.Status.INTERNAL_SERVER_ERROR);
responseMsg.setResponseMessage("Device enrollment failed.");
responseMsg.setResponseCode(Response.Status.INTERNAL_SERVER_ERROR.toString());
}
} catch (DeviceManagementException e) {
msg = "Error occurred while enrolling the device";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@GET
@Path("{deviceId}")
public Message isEnrolled(@PathParam("deviceId") String id) throws AndroidAgentException {
String msg;
boolean result;
Message responseMsg = new Message();
DeviceIdentifier deviceIdentifier = AndroidAPIUtils.convertToDeviceIdentifierObject(id);
try {
result = AndroidAPIUtils.getDeviceManagementService().isEnrolled(deviceIdentifier);
if (result) {
responseMsg.setResponseMessage("Device has already enrolled");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
Response.status(Response.Status.ACCEPTED);
} else {
responseMsg.setResponseMessage("Device not found");
responseMsg.setResponseCode(Response.Status.NOT_FOUND.toString());
Response.status(Response.Status.NOT_FOUND);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while checking enrollment status of the device.";
responseMsg.setResponseMessage(msg);
responseMsg.setResponseCode(Response.Status.INTERNAL_SERVER_ERROR.toString());
Response.status(Response.Status.INTERNAL_SERVER_ERROR);
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@PUT
@Path("{deviceId}")
public Message modifyEnrollment(@PathParam("deviceId") String id,
org.wso2.carbon.device.mgt.common.Device device)
throws AndroidAgentException {
String msg;
boolean result;
Message responseMsg = new Message();
try {
device.setType(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_ANDROID);
result = AndroidAPIUtils.getDeviceManagementService().modifyEnrollment(device);
if (result) {
responseMsg.setResponseMessage("Device enrollment has updated successfully");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
Response.status(Response.Status.ACCEPTED);
} else {
responseMsg.setResponseMessage("Device not found for enrollment");
responseMsg.setResponseCode(Response.Status.NOT_MODIFIED.toString());
Response.status(Response.Status.NOT_MODIFIED);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while modifying enrollment of the device";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
@DELETE
@Path("{deviceId}")
public Message disEnrollDevice(@PathParam("deviceId") String id) throws AndroidAgentException {
Message responseMsg = new Message();
boolean result;
String msg;
DeviceIdentifier deviceIdentifier = AndroidAPIUtils.convertToDeviceIdentifierObject(id);
try {
result = AndroidAPIUtils.getDeviceManagementService().disenrollDevice(deviceIdentifier);
if (result) {
responseMsg.setResponseMessage("Device has removed successfully");
responseMsg.setResponseCode(Response.Status.ACCEPTED.toString());
Response.status(Response.Status.ACCEPTED);
} else {
responseMsg.setResponseMessage("Device not found");
responseMsg.setResponseCode(Response.Status.NOT_FOUND.toString());
Response.status(Response.Status.NOT_FOUND);
}
} catch (DeviceManagementException e) {
msg = "Error occurred while dis enrolling the device";
log.error(msg, e);
throw new AndroidAgentException(msg, e);
}
return responseMsg;
}
}

414
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/operationmgt/OperationMgtService.java Normal file
View File

@ -0,0 +1,414 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.operationmgt;
import io.swagger.annotations.*;
import org.wso2.carbon.device.mgt.common.operation.mgt.Operation;
import org.wso2.carbon.mdm.services.android.bean.wrapper.*;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Android Device Operation REST-API implementation.
*/
@Api("OperationMgtService")
public interface OperationMgtService {
String ACCEPT = "Accept";
@PUT
@Path("{id}")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "PUT",
value = "Getting Pending Android Device Operations",
responseContainer = "List",
notes = "The Android agent communicates with the server to get the operations that are queued up " +
"at the server end for a given device using this REST API",
response = Operation.class)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "List of pending operations"),
@ApiResponse(code = 500, message = "Issue in retrieving operation management service instance")
})
List<? extends Operation> getPendingOperations(
@ApiParam(name = "acceptHeader", value = "Accept Header") @HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "id", value = "DeviceIdentifier") @PathParam("id") String id,
@ApiParam(name = "resultOperations", value = "Device Operation Status")
List<? extends Operation> resultOperations);
@POST
@Path("lock")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Adding a Device Lock on Android Devices",
responseContainer = "List",
notes = "Using this API you have the option of hard locking an Android device, where the Administrator " +
"permanently locks the device or screen locking an Android device",
response = String.class)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response configureDeviceLock(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIDs", value =
"DeviceIds to be enable device lock operation")
List<String> deviceIDs);
@POST
@Path("location")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Requesting Location Coordinates of Android Devices",
responseContainer = "List",
notes = "Request location coordinates of Android devices",
response = String.class)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Requested Device Coordinates"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")})
Response getDeviceLocation(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIDs",
value = "DeviceIDs to be requested to get device location")
List<String> deviceIDs);
@POST
@Path("clear-password")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Clearing the Password on Android Devices",
notes = "Clear the password on Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response removePassword(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIDs",
value = "DeviceIds to be requested to remove password")
List<String> deviceIDs);
@POST
@Path("camera")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Enabling or Disabling the Camera on Android Devices",
notes = "Enable or disable the camera on Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in creating a new camera instance")
})
Response configureCamera(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "cameraBeanWrapper",
value = "Camera enable/disable configurations with device IDs") CameraBeanWrapper cameraBeanWrapper);
@POST
@Path("device-info")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Requesting Information from Android Devices",
notes = "Using this REST API you are able to request for Android device details. Once this REST API is" +
" executed it will be in the Android operation queue until the device calls the server to retrieve " +
"the list of operations that needs to be executed on the device"
)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Device Information"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response getDeviceInformation(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIds",
value = "Device IDs to be requested to get device information")
List<String> deviceIDs);
@POST
@Path("enterprise-wipe")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Enterprise Wiping Android Devices",
notes = "Enterprise wipe is the process of deleting enterprise related data on a device while keeping the " +
"personal data intact. You are able to enterprise wipe Android devices using this REST API"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance"
)})
Response wipeDevice(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIDs",
value = "Device IDs to be requested to done enterprise-wipe")
List<String> deviceIDs);
@POST
@Path("wipe-data")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Factory Resetting an Android Device",
notes = "Factory rest or erases all the data stored in the Android devices " +
"to restore them back to the original system"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")})
Response wipeData(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "wipeDataBeanWrapper",
value = "Configurations and DeviceIds to be need to done wipe-data")
WipeDataBeanWrapper wipeDataBeanWrapper);
@POST
@Path("application-list")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Requesting the List of Installed Applications on Android Devices",
notes = "Using this REST API the server requests for the list of applications that are installed on" +
" the Android devices. Once this REST API is executed it will be in the Android operation queue " +
"until the device calls the server to retrieve the list of operations that needs to be executed " +
"on the device"
)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "List of applications for specific deviceIdentifier"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response getApplications(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIDs",
value = "Device Ids to be need to get applications which already installed")
List<String> deviceIDs);
@POST
@Path("ring-device")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Ringing Android Devices",
notes = "Ring Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response ringDevice(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "deviceIDs",
value = "Device Ids needs to be ring") List<String> deviceIDs);
@POST
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Muting Android Devices",
notes = "Mute Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
@Path("mute")
Response muteDevice(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "deviceIDs", value = "DeviceIDs need to be muted") List<String> deviceIDs);
@POST
@Path("install-application")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Installing an Application on Android Devices",
notes = "Install an application on an Android device. If the device you are installing the application" +
" on has the WSO2 system service installed, the application installation will happen in silent " +
"mode, else the device user's consent will be required"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response installApplication(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "applicationInstallationBeanWrapper",
value = "Properties of installed apps and device IDs")
ApplicationInstallationBeanWrapper applicationInstallationBeanWrapper);
@POST
@Path("uninstall-application")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Uninstalling an Application from Android Devices",
notes = "Uninstall an application from Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response uninstallApplication(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "applicationUninstallationBeanWrapper",
value = "applicationUninstallationConfigs and Device Ids")
ApplicationUninstallationBeanWrapper applicationUninstallationBeanWrapper);
@POST
@Path("blacklist-applications")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Get BlackListed Applications",
notes = "Getting BlackListed Applications"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response blacklistApplications(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "blacklistApplicationsBeanWrapper",
value = "BlacklistApplications Configuration and DeviceIds")
BlacklistApplicationsBeanWrapper blacklistApplicationsBeanWrapper);
@POST
@Path("notification")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Sending a Notification to Android Devices",
notes = "Send a notification to Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response sendNotification(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "notificationBeanWrapper",
value = "Notification Configurations and device Ids")
NotificationBeanWrapper notificationBeanWrapper);
@POST
@Path("wifi")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Configuring Wi-Fi on Android Devices",
notes = "Configure Wi-Fi on Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response configureWifi(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "wifiBeanWrapper",
value = "WifiConfigurations and Device Ids") WifiBeanWrapper wifiBeanWrapper);
@POST
@Path("encrypt")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Encrypting Storage on Android Devices",
notes = "Encrypt the data stored on Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response encryptStorage(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "encryptionBeanWrapper",
value = "Configurations and deviceIds need to be done data encryption")
EncryptionBeanWrapper encryptionBeanWrapper);
@POST
@Path("change-lock-code")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Changing the Lock Code on Android Devices",
notes = "Change the lock code on Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response changeLockCode(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "lockCodeBeanWrapper",
value = "Configurations and device Ids need to be done change lock code")
LockCodeBeanWrapper lockCodeBeanWrapper);
@POST
@Path("password-policy")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Setting a Passcode Policy on Android Devices",
notes = "Set a password policy on Android devices"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "created"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response setPasswordPolicy(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "passwordPolicyBeanWrapper",
value = "Password Policy Configurations and Device Ids")
PasswordPolicyBeanWrapper passwordPolicyBeanWrapper);
@POST
@Path("webclip")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Setting a Web Clip on Android Devices",
notes = "Set a web clip on Android devices. A web clip is used to add a bookmark to a web application"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Accepted"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response setWebClip(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader, @ApiParam(name = "webClipBeanWrapper",
value = "Configurations to need set web clip on device and device Ids")
WebClipBeanWrapper webClipBeanWrapper);
@POST
@Path("disenroll")
@ApiOperation(
consumes = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Un-Register The Device from the EMM server",
notes = "unregister the given device"
)
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Accepted"),
@ApiResponse(code = 500, message = "Issue in retrieving device management service instance")
})
Response setDisenrollment(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam(ACCEPT) String acceptHeader,
@ApiParam(name = "disenrollmentBeanWrapper", value = "Dis-enrollment configurations")
DisenrollmentBeanWrapper disenrollmentBeanWrapper);
}

49
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/OperationMgtService.java → components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/operationmgt/impl/OperationMgtServiceImpl.java
View File

@ -16,22 +16,22 @@
* under the License.
*/
package org.wso2.carbon.mdm.services.android;
package org.wso2.carbon.mdm.services.android.services.operationmgt.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManagementException;
import org.wso2.carbon.device.mgt.common.notification.mgt.*;
import org.wso2.carbon.device.mgt.common.notification.mgt.NotificationManagementException;
import org.wso2.carbon.device.mgt.common.operation.mgt.Operation;
import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
import org.wso2.carbon.device.mgt.core.operation.mgt.CommandOperation;
import org.wso2.carbon.device.mgt.core.operation.mgt.ProfileOperation;
import org.wso2.carbon.mdm.services.android.bean.*;
import org.wso2.carbon.mdm.services.android.bean.Notification;
import org.wso2.carbon.mdm.services.android.bean.wrapper.*;
import org.wso2.carbon.mdm.services.android.exception.AndroidOperationException;
import org.wso2.carbon.mdm.services.android.services.operationmgt.OperationMgtService;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.AndroidConstants;
import org.wso2.carbon.mdm.services.android.util.AndroidDeviceUtils;
@ -43,15 +43,12 @@ import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Android Device Operation REST-API implementation.
*/
public class OperationMgtService {
public class OperationMgtServiceImpl {
private static Log log = LogFactory.getLog(OperationMgtService.class);
private static final String ACCEPT = "Accept";
private static final String OPERATION_ERROR_STATUS = "ERROR";
private static final String DEVICE_TYPE_ANDROID = "android";
private static final String OPERATION_ERROR_STATUS = "ERROR";
private static final String DEVICE_TYPE_ANDROID = "android";
@PUT
@Path("{id}")
@ -93,7 +90,7 @@ public class OperationMgtService {
} catch (ApplicationManagementException e) {
log.error("Issue in retrieving application management service instance", e);
} catch (NotificationManagementException e) {
log.error("Issue in retrieving Notification management service instance", e);
log.error("Issue in retrieving Notification management service instance", e);
}
List<? extends Operation> pendingOperations;
@ -268,7 +265,7 @@ public class OperationMgtService {
CommandOperation operation = new CommandOperation();
operation.setCode(AndroidConstants.OperationCodes.DEVICE_INFO);
operation.setType(Operation.Type.COMMAND);
getApplications(acceptHeader, deviceIDs);
getApplications(acceptHeader, deviceIDs);
return AndroidAPIUtils.getOperationResponse(deviceIDs, operation, message,
responseMediaType);
} catch (OperationManagementException e) {
@ -908,21 +905,21 @@ public class OperationMgtService {
ApplicationManagementException, NotificationManagementException, DeviceManagementException {
for (org.wso2.carbon.device.mgt.common.operation.mgt.Operation operation : operations) {
AndroidAPIUtils.updateOperation(deviceId, operation);
if(operation.getStatus().equals(OPERATION_ERROR_STATUS)){
org.wso2.carbon.device.mgt.common.notification.mgt.Notification notification = new
org.wso2.carbon.device.mgt.common.notification.mgt.Notification();
DeviceIdentifier id = new DeviceIdentifier();
id.setId(deviceId);
id.setType(DEVICE_TYPE_ANDROID);
String deviceName = AndroidAPIUtils.getDeviceManagementService().getDevice(id).getName();
notification.setOperationId(operation.getId());
notification.setStatus(org.wso2.carbon.device.mgt.common.notification.mgt.Notification.
Status.NEW.toString());
notification.setDeviceIdentifier(id);
notification.setDescription("Operation " + operation.getCode() + " failed to execute on device "+
deviceName+". Device ID : " + deviceId);
AndroidAPIUtils.getNotificationManagementService().addNotification(notification);
}
if (operation.getStatus().equals(OPERATION_ERROR_STATUS)) {
org.wso2.carbon.device.mgt.common.notification.mgt.Notification notification = new
org.wso2.carbon.device.mgt.common.notification.mgt.Notification();
DeviceIdentifier id = new DeviceIdentifier();
id.setId(deviceId);
id.setType(DEVICE_TYPE_ANDROID);
String deviceName = AndroidAPIUtils.getDeviceManagementService().getDevice(id).getName();
notification.setOperationId(operation.getId());
notification.setStatus(org.wso2.carbon.device.mgt.common.notification.mgt.Notification.
Status.NEW.toString());
notification.setDeviceIdentifier(id);
notification.setDescription("Operation " + operation.getCode() + " failed to execute on device " +
deviceName + ". Device ID : " + deviceId);
AndroidAPIUtils.getNotificationManagementService().addNotification(notification);
}
if (log.isDebugEnabled()) {
log.debug("Updating operation '" + operation.toString() + "'");
}

73
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/policymgt/PolicyMgtService.java Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.mdm.services.android.services.policymgt;
import io.swagger.annotations.*;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.util.Message;
import org.wso2.carbon.policy.mgt.common.ProfileFeature;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.List;
@Api("PolicyMgtService")
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public interface PolicyMgtService {
@GET
@Path("{deviceId}")
@ApiOperation(
httpMethod = "GET",
value = "Identifying whether a Policy is Enforced on an Android Device",
notes = "When a device registers with WSO2 EMM, a policy is enforced on the device based on the policy " +
"enforcement criteria. Using this API you are able to identify if a specific device has a policy " +
"enforced or if no policy is enforced on the device."
)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Effective policy added to operation"),
@ApiResponse(code = 204, message = "No effective policy found")
})
Message getEffectivePolicy(@ApiParam(name = "acceptHeader", value = "Accept Header") @HeaderParam("Accept")
String acceptHeader,
@ApiParam(name = "deviceId", value = "DeviceIdentifier") @PathParam("deviceId")
String id) throws AndroidAgentException;
@GET
@Path("/features/{deviceId}")
@ApiOperation(
produces = MediaType.APPLICATION_JSON,
httpMethod = "GET",
value = "Get Effective Features",
responseContainer = "List",
notes = "Get already applied features for given device Identifier",
response = ProfileFeature.class)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Effective Feature List"),
@ApiResponse(code = 404, message = "Not Found"),
@ApiResponse(code = 500, message = "Error occurred while getting the features")
})
List<ProfileFeature> getEffectiveFeatures(@ApiParam(name = "acceptHeader", value = "Accept Header")
@HeaderParam("Accept") String acceptHeader,
@ApiParam(name = "deviceId", value = "DeviceIdentifier")
@PathParam("deviceId") String id) throws AndroidAgentException;
}

17
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/PolicyMgtService.java → components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/java/org/wso2/carbon/mdm/services/android/services/policymgt/impl/PolicyMgtServiceImpl.java
View File

@ -16,14 +16,13 @@
* under the License.
*/
package org.wso2.carbon.mdm.services.android;
package org.wso2.carbon.mdm.services.android.services.policymgt.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.mdm.services.android.exception.AndroidAgentException;
import org.wso2.carbon.mdm.services.android.services.policymgt.PolicyMgtService;
import org.wso2.carbon.mdm.services.android.util.AndroidAPIUtils;
import org.wso2.carbon.mdm.services.android.util.Message;
import org.wso2.carbon.policy.mgt.common.FeatureManagementException;
@ -32,16 +31,14 @@ import org.wso2.carbon.policy.mgt.common.PolicyManagementException;
import org.wso2.carbon.policy.mgt.common.ProfileFeature;
import org.wso2.carbon.policy.mgt.core.PolicyManagerService;
import javax.jws.WebService;
import javax.ws.rs.*;
import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.Response;
import java.util.List;
@WebService
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public class PolicyMgtService {
public class PolicyMgtServiceImpl {
private static Log log = LogFactory.getLog(PolicyMgtService.class);
@GET

10
components/mobile-plugins/android-plugin/org.wso2.carbon.device.mgt.mobile.android.api/src/main/webapp/WEB-INF/cxf-servlet.xml
View File

@ -69,11 +69,11 @@
</jaxrs:providers>
</jaxrs:server>
<bean id="deviceMgtServiceBean" class="org.wso2.carbon.mdm.services.android.DeviceManagementService"/>
<bean id="enrollmentServiceBean" class="org.wso2.carbon.mdm.services.android.EnrollmentService"/>
<bean id="operationServiceBean" class="org.wso2.carbon.mdm.services.android.OperationMgtService"/>
<bean id="policyServiceBean" class="org.wso2.carbon.mdm.services.android.PolicyMgtService"/>
<bean id="configurationServiceBean" class="org.wso2.carbon.mdm.services.android.ConfigurationMgtService"/>
<bean id="deviceMgtServiceBean" class="org.wso2.carbon.mdm.services.android.services.devicemgt.DeviceManagementServiceImpl"/>
<bean id="enrollmentServiceBean" class="org.wso2.carbon.mdm.services.android.services.enrollment.EnrollmentServiceImpl"/>
<bean id="operationServiceBean" class="org.wso2.carbon.mdm.services.android.services.operationmgt.OperationMgtServiceImpl"/>
<bean id="policyServiceBean" class="org.wso2.carbon.mdm.services.android.services.policymgt.PolicyMgtServiceImpl"/>
<bean id="configurationServiceBean" class="org.wso2.carbon.mdm.services.android.services.configuration.ConfigurationMgtServiceImpl"/>
<bean id="jsonProvider" class="org.wso2.carbon.mdm.services.android.common.GsonMessageBodyHandler"/>
<bean id="errorHandler" class="org.wso2.carbon.mdm.services.android.common.ErrorHandler"/>
</beans>

42
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/android/AndroidDeviceManager.java
View File

@ -69,7 +69,7 @@ public class AndroidDeviceManager implements DeviceManager {
} catch (LicenseManagementException e) {
log.error("Error occurred while adding default license for Android devices", e);
} catch (DeviceManagementException e) {
log.error("Error occurred while adding supported device features for Android platform", e);
throw new IllegalStateException("Error occurred while adding Android features to the DB.");
}
}
@ -101,13 +101,13 @@ public class AndroidDeviceManager implements DeviceManager {
status = true;
} catch (MobileDeviceMgtPluginException e) {
throw new DeviceManagementException(
"Error occurred while retrieving the Registry instance : " + e.getMessage(), e);
"Error occurred while retrieving the Registry instance", e);
} catch (RegistryException e) {
throw new DeviceManagementException(
"Error occurred while persisting the Registry resource of Android Configuration : " + e.getMessage(), e);
"Error occurred while persisting the Registry resource of Android Configuration", e);
} catch (JAXBException e) {
throw new DeviceManagementException(
"Error occurred while parsing the Android configuration : " + e.getMessage(), e);
"Error occurred while parsing the Android configuration", e);
}
return status;
}
@ -130,13 +130,13 @@ public class AndroidDeviceManager implements DeviceManager {
return null;
} catch (MobileDeviceMgtPluginException e) {
throw new DeviceManagementException(
"Error occurred while retrieving the Registry instance : " + e.getMessage(), e);
"Error occurred while retrieving the Registry instance", e);
} catch (JAXBException e) {
throw new DeviceManagementException(
"Error occurred while parsing the Android configuration : " + e.getMessage(), e);
"Error occurred while parsing the Android configuration", e);
} catch (RegistryException e) {
throw new DeviceManagementException(
"Error occurred while retrieving the Registry resource of Android Configuration : " + e.getMessage(), e);
"Error occurred while retrieving the Registry resource of Android Configuration", e);
}
}
@ -163,12 +163,10 @@ public class AndroidDeviceManager implements DeviceManager {
try {
AndroidDAOFactory.rollbackTransaction();
} catch (MobileDeviceManagementDAOException mobileDAOEx) {
String msg = "Error occurred while roll back the device enrol transaction :" +
device.toString();
String msg = "Error occurred while roll back the device enrol transaction :" + device.toString();
log.warn(msg, mobileDAOEx);
}
String msg =
"Error while enrolling the Android device : " + device.getDeviceIdentifier();
String msg = "Error occurred while enrolling the Android device : " + device.getDeviceIdentifier();
throw new DeviceManagementException(msg, e);
}
return status;
@ -189,11 +187,10 @@ public class AndroidDeviceManager implements DeviceManager {
try {
AndroidDAOFactory.rollbackTransaction();
} catch (MobileDeviceManagementDAOException mobileDAOEx) {
String msg = "Error occurred while roll back the update device transaction :" +
device.toString();
String msg = "Error occurred while roll back the update device transaction :" + device.toString();
log.warn(msg, mobileDAOEx);
}
String msg = "Error while updating the enrollment of the Android device : " +
String msg = "Error occurred while updating the enrollment of the Android device : " +
device.getDeviceIdentifier();
throw new DeviceManagementException(msg, e);
}
@ -219,8 +216,7 @@ public class AndroidDeviceManager implements DeviceManager {
isEnrolled = true;
}
} catch (MobileDeviceManagementDAOException e) {
String msg = "Error while checking the enrollment status of Android device : " +
deviceId.getId();
String msg = "Error occurred while checking the enrollment status of Android device : " + deviceId.getId();
throw new DeviceManagementException(msg, e);
}
return isEnrolled;
@ -249,8 +245,7 @@ public class AndroidDeviceManager implements DeviceManager {
device = MobileDeviceManagementUtil.convertToDevice(mobileDevice);
} catch (MobileDeviceManagementDAOException e) {
throw new DeviceManagementException(
"Error occurred while fetching the Android device: '" +
deviceId.getId() + "'", e);
"Error occurred while fetching the Android device: '" + deviceId.getId() + "'", e);
}
return device;
}
@ -294,12 +289,9 @@ public class AndroidDeviceManager implements DeviceManager {
boolean status;
Device existingDevice = this.getDevice(deviceIdentifier);
// This object holds the current persisted device object
MobileDevice existingMobileDevice =
MobileDeviceManagementUtil.convertToMobileDevice(existingDevice);
MobileDevice existingMobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(existingDevice);
// This object holds the newly received device object from response
MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device);
// Updating current object features using newer ones
existingMobileDevice.setLatitude(mobileDevice.getLatitude());
existingMobileDevice.setLongitude(mobileDevice.getLongitude());
@ -321,8 +313,7 @@ public class AndroidDeviceManager implements DeviceManager {
device.toString() + "'", e1);
}
throw new DeviceManagementException(
"Error occurred while updating the Android device: '" +
device.getDeviceIdentifier() + "'", e);
"Error occurred while updating the Android device: '" + device.getDeviceIdentifier() + "'", e);
}
return status;
}
@ -343,8 +334,7 @@ public class AndroidDeviceManager implements DeviceManager {
}
}
} catch (MobileDeviceManagementDAOException e) {
throw new DeviceManagementException("Error occurred while fetching all Android devices",
e);
throw new DeviceManagementException("Error occurred while fetching all Android devices", e);
}
return devices;
}

74
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/WindowsDeviceManager.java
View File

@ -69,7 +69,7 @@ public class WindowsDeviceManager implements DeviceManager {
} catch (LicenseManagementException e) {
log.error("Error occurred while adding default license for Windows devices", e);
} catch (DeviceManagementException e) {
log.error("Error occurred while adding supported device features for Windows platform", e);
throw new IllegalStateException("Error occurred while adding windows features to the DB.");
}
}
@ -79,8 +79,7 @@ public class WindowsDeviceManager implements DeviceManager {
}
@Override
public boolean saveConfiguration(TenantConfiguration tenantConfiguration)
throws DeviceManagementException {
public boolean saveConfiguration(TenantConfiguration tenantConfiguration) throws DeviceManagementException {
boolean status;
Resource resource;
try {
@ -88,8 +87,7 @@ public class WindowsDeviceManager implements DeviceManager {
log.debug("Persisting windows configurations in Registry");
}
String resourcePath = MobileDeviceManagementUtil.getPlatformConfigPath(
DeviceManagementConstants.
MobileDeviceTypes.MOBILE_DEVICE_TYPE_WINDOWS);
DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_WINDOWS);
StringWriter writer = new StringWriter();
JAXBContext context = JAXBContext.newInstance(TenantConfiguration.class);
Marshaller marshaller = context.createMarshaller();
@ -102,13 +100,13 @@ public class WindowsDeviceManager implements DeviceManager {
status = true;
} catch (MobileDeviceMgtPluginException e) {
throw new DeviceManagementException(
"Error occurred while retrieving the Registry instance : " + e.getMessage(), e);
"Error occurred while retrieving the Registry instance", e);
} catch (RegistryException e) {
throw new DeviceManagementException(
"Error occurred while persisting the Registry resource of Windows configuration : " + e.getMessage(), e);
"Error occurred while persisting the Registry resource of Windows configuration", e);
} catch (JAXBException e) {
throw new DeviceManagementException(
"Error occurred while parsing the Windows configuration : " + e.getMessage(), e);
"Error occurred while parsing the Windows configuration", e);
}
return status;
}
@ -117,45 +115,46 @@ public class WindowsDeviceManager implements DeviceManager {
public TenantConfiguration getConfiguration() throws DeviceManagementException {
Resource resource;
try {
String windowsTenantRegistryPath =
MobileDeviceManagementUtil.getPlatformConfigPath(DeviceManagementConstants.
MobileDeviceTypes.MOBILE_DEVICE_TYPE_WINDOWS);
String windowsTenantRegistryPath = MobileDeviceManagementUtil.
getPlatformConfigPath(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_WINDOWS);
resource = MobileDeviceManagementUtil.getRegistryResource(windowsTenantRegistryPath);
if (resource != null) {
JAXBContext context = JAXBContext.newInstance(TenantConfiguration.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
return (TenantConfiguration) unmarshaller.unmarshal(
new StringReader(new String((byte[]) resource.getContent(), Charset.
return (TenantConfiguration) unmarshaller.unmarshal(new StringReader(
new String((byte[]) resource.getContent(), Charset.
forName(MobilePluginConstants.CHARSET_UTF8))));
}
return null;
} catch (MobileDeviceMgtPluginException e) {
throw new DeviceManagementException(
"Error occurred while retrieving the Registry instance : " + e.getMessage(), e);
"Error occurred while retrieving the Registry instance", e);
} catch (JAXBException e) {
throw new DeviceManagementException(
"Error occurred while parsing the Windows configuration : " + e.getMessage(), e);
"Error occurred while parsing the Windows configuration", e);
} catch (RegistryException e) {
throw new DeviceManagementException(
"Error occurred while retrieving the Registry resource of Windows configuration : " + e.getMessage(), e);
"Error occurred while retrieving the Registry resource of Windows configuration", e);
}
}
@Override
public boolean modifyEnrollment(Device device) throws DeviceManagementException {
boolean status;
boolean status = false;
MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device);
try {
if (log.isDebugEnabled()) {
log.debug("Modifying the Windows device enrollment data");
}
WindowsDAOFactory.beginTransaction();
status = daoFactory.getMobileDeviceDAO().updateMobileDevice(mobileDevice);
if (daoFactory.getMobileDeviceDAO() != null) {
status = daoFactory.getMobileDeviceDAO().updateMobileDevice(mobileDevice);
}
WindowsDAOFactory.commitTransaction();
} catch (MobileDeviceManagementDAOException e) {
WindowsDAOFactory.rollbackTransaction();
throw new DeviceManagementException("Error while updating the enrollment of the Windows device : " +
device.getDeviceIdentifier(), e);
throw new DeviceManagementException("Error occurred while updating the enrollment of the " +
"Windows device : " + device.getDeviceIdentifier(), e);
} finally {
WindowsDAOFactory.closeConnection();
}
@ -170,22 +169,21 @@ public class WindowsDeviceManager implements DeviceManager {
@Override
public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
boolean isEnrolled = false;
MobileDevice mobileDevice;
try {
if (log.isDebugEnabled()) {
log.debug("Checking the enrollment of Windows device : " + deviceId.getId());
}
MobileDevice mobileDevice =
daoFactory.getMobileDeviceDAO().getMobileDevice(deviceId.getId());
if (mobileDevice != null) {
isEnrolled = true;
if (daoFactory.getMobileDeviceDAO() != null) {
mobileDevice = daoFactory.getMobileDeviceDAO().getMobileDevice(deviceId.getId());
} else {
throw new DeviceManagementException("Error occurred while getting DAO object.");
}
} catch (MobileDeviceManagementDAOException e) {
String msg = "Error while checking the enrollment status of Windows device : " +
deviceId.getId();
String msg = "Error occurred while checking the enrollment status of Windows device : " + deviceId.getId();
throw new DeviceManagementException(msg, e);
}
return isEnrolled;
return (mobileDevice != null);
}
@Override
@ -201,12 +199,15 @@ public class WindowsDeviceManager implements DeviceManager {
public List<Device> getAllDevices() throws DeviceManagementException {
List<Device> devices = null;
List<MobileDevice> mobileDevices = null;
try {
if (log.isDebugEnabled()) {
log.debug("Fetching the details of all Windows devices");
}
WindowsDAOFactory.openConnection();
List<MobileDevice> mobileDevices = daoFactory.getMobileDeviceDAO().getAllMobileDevices();
if (daoFactory.getMobileDeviceDAO() != null) {
mobileDevices = daoFactory.getMobileDeviceDAO().getAllMobileDevices();
}
if (mobileDevices != null) {
devices = new ArrayList<>(mobileDevices.size());
for (MobileDevice mobileDevice : mobileDevices) {
@ -224,13 +225,15 @@ public class WindowsDeviceManager implements DeviceManager {
@Override
public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
Device device = null;
MobileDevice mobileDevice = null;
try {
if (log.isDebugEnabled()) {
log.debug("Getting the details of Windows device : '" + deviceId.getId() + "'");
}
WindowsDAOFactory.openConnection();
MobileDevice mobileDevice = daoFactory.getMobileDeviceDAO().
getMobileDevice(deviceId.getId());
if (daoFactory.getMobileDeviceDAO() != null) {
mobileDevice = daoFactory.getMobileDeviceDAO().getMobileDevice(deviceId.getId());
}
device = MobileDeviceManagementUtil.convertToDevice(mobileDevice);
} catch (MobileDeviceManagementDAOException e) {
throw new DeviceManagementException(
@ -293,14 +296,15 @@ public class WindowsDeviceManager implements DeviceManager {
this.modifyEnrollment(device);
} else {
WindowsDAOFactory.beginTransaction();
status = daoFactory.getMobileDeviceDAO().addMobileDevice(mobileDevice);
if (daoFactory.getMobileDeviceDAO() != null) {
status = daoFactory.getMobileDeviceDAO().addMobileDevice(mobileDevice);
}
WindowsDAOFactory.commitTransaction();
}
} catch (MobileDeviceManagementDAOException e) {
WindowsDAOFactory.rollbackTransaction();
String msg =
"Error while enrolling the windows device : " + device.getDeviceIdentifier();
throw new DeviceManagementException(msg, e);
throw new DeviceManagementException("Error occurred while enrolling the windows device : "
+ device.getDeviceIdentifier(), e);
}
return status;
}

24
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/WindowsFeatureManager.java
View File

@ -26,6 +26,7 @@ import org.wso2.carbon.device.mgt.mobile.dao.MobileDeviceManagementDAOFactory;
import org.wso2.carbon.device.mgt.mobile.dao.MobileFeatureDAO;
import org.wso2.carbon.device.mgt.mobile.dto.MobileFeature;
import org.wso2.carbon.device.mgt.mobile.impl.windows.dao.WindowsDAOFactory;
import org.wso2.carbon.device.mgt.mobile.impl.windows.util.WindowsUtils;
import org.wso2.carbon.device.mgt.mobile.util.MobileDeviceManagementUtil;
import java.util.ArrayList;
@ -116,13 +117,13 @@ public class WindowsFeatureManager implements FeatureManager {
featureDAO.deleteFeatureByCode(code);
WindowsDAOFactory.commitTransaction();
status = true;
return status;
} catch (MobileDeviceManagementDAOException e) {
WindowsDAOFactory.rollbackTransaction();
throw new DeviceManagementException("Error occurred while removing the feature", e);
} finally {
WindowsDAOFactory.closeConnection();
}
return status;
}
@Override
@ -145,48 +146,49 @@ public class WindowsFeatureManager implements FeatureManager {
* @return Supported features.
*/
public static List<Feature> getSupportedFeatures() {
List<Feature> supportedFeatures = new ArrayList<Feature>();
Feature feature = new Feature();
List<Feature> supportedFeatures = new ArrayList<>();
Feature feature;
feature = WindowsUtils.getMobileFeature();
feature.setCode("DEVICE_LOCK");
feature.setName("Device Lock");
feature.setDescription("Lock the device");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("CAMERA");
feature.setName("camera");
feature.setDescription("Enable or disable camera");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("DEVICE_INFO");
feature.setName("Device info");
feature.setDescription("Request device information");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("WIPE_DATA");
feature.setName("Wipe Data");
feature.setDescription("Factory reset the device");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("ENCRYPT_STORAGE");
feature.setName("Encrypt storage");
feature.setDescription("Encrypt storage");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("DEVICE_RING");
feature.setName("Ring");
feature.setDescription("Ring the device");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("PASSCODE_POLICY");
feature.setName("Password Policy");
feature.setDescription("Set passcode policy");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("DISENROLL");
feature.setName("DisEnroll");
feature.setDescription("DisEnroll the device");
supportedFeatures.add(feature);
feature = new Feature();
feature = WindowsUtils.getMobileFeature();
feature.setCode("LOCK_RESET");
feature.setName("LockReset");
feature.setDescription("Lock Reset device");

3
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/dao/WindowsDAOFactory.java
View File

@ -39,7 +39,8 @@ public class WindowsDAOFactory extends AbstractMobileDeviceManagementDAOFactory
private static ThreadLocal<Connection> currentConnection = new ThreadLocal<>();
public WindowsDAOFactory() {
this.dataSource = getDataSourceMap().get(DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_WINDOWS);
this.dataSource = getDataSourceMap().get(
DeviceManagementConstants.MobileDeviceTypes.MOBILE_DEVICE_TYPE_WINDOWS);
}
@Override

2
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/dao/WindowsFeatureManagementDAOException.java
View File

@ -21,7 +21,7 @@ package org.wso2.carbon.device.mgt.mobile.impl.windows.dao;
import org.wso2.carbon.device.mgt.mobile.dao.MobileDeviceManagementDAOException;
/**
* Implement Exception class for Windows Device Features.
* This class responsible for wrapping exceptions related on Windows device features.
*/
public class WindowsFeatureManagementDAOException extends MobileDeviceManagementDAOException {

23
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/dao/impl/WindowsDeviceDAOImpl.java
View File

@ -25,6 +25,7 @@ import org.wso2.carbon.device.mgt.mobile.dao.util.MobileDeviceManagementDAOUtil;
import org.wso2.carbon.device.mgt.mobile.dto.MobileDevice;
import org.wso2.carbon.device.mgt.mobile.impl.windows.dao.WindowsDAOFactory;
import org.wso2.carbon.device.mgt.mobile.impl.windows.util.WindowsPluginConstants;
import org.wso2.carbon.device.mgt.mobile.impl.windows.util.WindowsUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
@ -60,17 +61,7 @@ public class WindowsDeviceDAOImpl implements MobileDeviceDAO {
rs = stmt.executeQuery();
while (rs.next()) {
mobileDevice = new MobileDevice();
mobileDevice.setMobileDeviceId(rs.getString(WindowsPluginConstants.DEVICE_ID));
mobileDevice.setImei(rs.getString(WindowsPluginConstants.IMEI));
mobileDevice.setImsi(rs.getString(WindowsPluginConstants.IMSI));
mobileDevice.setModel(rs.getString(WindowsPluginConstants.DEVICE_MODEL));
mobileDevice.setVendor(rs.getString(WindowsPluginConstants.VENDOR));
mobileDevice.setLatitude(rs.getString(WindowsPluginConstants.LATITUDE));
mobileDevice.setLongitude(rs.getString(WindowsPluginConstants.LONGITUDE));
mobileDevice.setSerial(rs.getString(WindowsPluginConstants.SERIAL));
mobileDevice.setOsVersion(rs.getString(WindowsPluginConstants.LATITUDE));
mobileDevice = WindowsUtils.loadMobileDevices(rs);
Map<String, String> propertyMap = new HashMap<>();
propertyMap.put(WindowsPluginConstants.CHANNEL_URI, rs.getString(WindowsPluginConstants.CHANNEL_URI));
propertyMap.put(WindowsPluginConstants.DEVICE_INFO, rs.getString(WindowsPluginConstants.DEVICE_INFO));
@ -225,15 +216,7 @@ public class WindowsDeviceDAOImpl implements MobileDeviceDAO {
rs = stmt.executeQuery();
while (rs.next()) {
mobileDevice = new MobileDevice();
mobileDevice.setMobileDeviceId(rs.getString(WindowsPluginConstants.DEVICE_ID));
mobileDevice.setVendor(rs.getString(WindowsPluginConstants.IMEI));
mobileDevice.setLatitude(rs.getString(WindowsPluginConstants.IMSI));
mobileDevice.setLongitude(rs.getString(WindowsPluginConstants.OS_VERSION));
mobileDevice.setImei(rs.getString(WindowsPluginConstants.DEVICE_MODEL));
mobileDevice.setImsi(rs.getString(WindowsPluginConstants.VENDOR));
mobileDevice.setOsVersion(rs.getString(WindowsPluginConstants.LATITUDE));
mobileDevice = WindowsUtils.loadMobileDevices(rs);
Map<String, String> propertyMap = new HashMap<>();
propertyMap.put(WindowsPluginConstants.CHANNEL_URI, rs.getString(WindowsPluginConstants.CHANNEL_URI));
propertyMap.put(WindowsPluginConstants.DEVICE_INFO, rs.getString(WindowsPluginConstants.DEVICE_INFO));

4
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/dao/impl/WindowsFeatureDAOImpl.java
View File

@ -43,10 +43,6 @@ public class WindowsFeatureDAOImpl implements MobileFeatureDAO {
private static final Log log = LogFactory.getLog(WindowsFeatureDAOImpl.class);
public WindowsFeatureDAOImpl() {
}
@Override
public boolean addFeature(MobileFeature mobileFeature) throws MobileDeviceManagementDAOException {
PreparedStatement stmt = null;

31
components/mobile-plugins/mobile-base-plugin/org.wso2.carbon.device.mgt.mobile/src/main/java/org/wso2/carbon/device/mgt/mobile/impl/windows/util/WindowsUtils.java
View File

@ -18,18 +18,33 @@
package org.wso2.carbon.device.mgt.mobile.impl.windows.util;
import java.util.Map;
import org.wso2.carbon.device.mgt.common.Feature;
import org.wso2.carbon.device.mgt.mobile.dto.MobileDevice;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Contains utility methods used by Windows plugin.
* Contains utility methods which are used by Windows plugin.
*/
public class WindowsUtils {
public static String getDeviceProperty(Map<String, String> deviceProperties, String property) {
String deviceProperty = deviceProperties.get(property);
if (deviceProperty == null) {
return null;
}
return deviceProperty;
public static MobileDevice loadMobileDevices(ResultSet rs) throws SQLException {
MobileDevice mobileDevice = new MobileDevice();
mobileDevice.setMobileDeviceId(rs.getString(WindowsPluginConstants.DEVICE_ID));
mobileDevice.setImei(rs.getString(WindowsPluginConstants.IMEI));
mobileDevice.setImsi(rs.getString(WindowsPluginConstants.IMSI));
mobileDevice.setModel(rs.getString(WindowsPluginConstants.DEVICE_MODEL));
mobileDevice.setVendor(rs.getString(WindowsPluginConstants.VENDOR));
mobileDevice.setLatitude(rs.getString(WindowsPluginConstants.LATITUDE));
mobileDevice.setLongitude(rs.getString(WindowsPluginConstants.LONGITUDE));
mobileDevice.setSerial(rs.getString(WindowsPluginConstants.SERIAL));
mobileDevice.setOsVersion(rs.getString(WindowsPluginConstants.LATITUDE));
return mobileDevice;
}
public static Feature getMobileFeature() {
Feature feature = new Feature();
return feature;
}
}

9
pom.xml
View File

@ -44,6 +44,12 @@
<dependencyManagement>
<dependencies>
<!--Swagger Dependency-->
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<version>${swagger.version}</version>
</dependency>
<!--Carbon Kernel Dependencies-->
<dependency>
@ -1087,6 +1093,9 @@
<!-- Jetty -->
<jetty.version>8.1.3.v20120416</jetty.version>
<!-- Swagger -->
<swagger.version>1.5.8</swagger.version>
<!-- Carbon Analytics -->
<carbon.analytics.common.version>5.0.11</carbon.analytics.common.version>
<carbon.analytics.common.version.range>[5.0.11,6.0.0)</carbon.analytics.common.version.range>