Add multiple push notification support and transport config for features

components/device-mgt/org.wso2.carbon.device.mgt.api/src/main/java/org/wso2/carbon/device/mgt/jaxrs/service/impl/DeviceTypeManagementServiceImpl.java

@@ -30,7 +30,6 @@ import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
 import org.wso2.carbon.device.mgt.jaxrs.beans.DeviceTypeList;
 import org.wso2.carbon.device.mgt.jaxrs.beans.ErrorResponse;
 import org.wso2.carbon.device.mgt.jaxrs.service.api.DeviceTypeManagementService;
-import org.wso2.carbon.device.mgt.jaxrs.service.impl.util.RequestValidationUtil;
 import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
 
 import javax.validation.constraints.Size;
@@ -38,9 +37,9 @@ import javax.ws.rs.GET;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.Path;
 import javax.ws.rs.PathParam;
-import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.Response;
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 
 @Path("/device-types")
@@ -79,7 +78,7 @@ public class DeviceTypeManagementServiceImpl implements DeviceTypeManagementServ
             if (fm == null) {
                 return Response.status(Response.Status.NOT_FOUND).entity(
                         new ErrorResponse.ErrorResponseBuilder().setMessage("No feature manager is " +
-                                                                                    "registered with the given type '" + type + "'").build()).build();
+                                "registered with the given type '" + type + "'").build()).build();
             }
             features = fm.getFeatures();
         } catch (DeviceManagementException e) {
@@ -133,6 +132,7 @@ public class DeviceTypeManagementServiceImpl implements DeviceTypeManagementServ
 
     /**
      * This cleans up the configs that should not be exposed to iot users.
+     *
      * @param deviceType
      * @return
      */
@@ -140,9 +140,13 @@ public class DeviceTypeManagementServiceImpl implements DeviceTypeManagementServ
         DeviceTypeMetaDefinition metaDefinition = deviceType.getDeviceTypeMetaDefinition();
         if (metaDefinition != null) {
             metaDefinition.setInitialOperationConfig(null);
-            if (metaDefinition.getPushNotificationConfig() != null) {
+            if (metaDefinition.getPushNotificationConfigs() != null) {
-                metaDefinition.setPushNotificationConfig(new PushNotificationConfig(metaDefinition.
+                List<PushNotificationConfig> pushNotificationConfigs = new LinkedList<>();
-                        getPushNotificationConfig().getType(), false, null));
+                for (PushNotificationConfig pushNotificationConfig : metaDefinition.getPushNotificationConfigs()) {
+                    pushNotificationConfigs.add(new PushNotificationConfig(pushNotificationConfig.getType(), false,
+                            false, null));
+                }
+                metaDefinition.setPushNotificationConfigs(pushNotificationConfigs);
             }
             deviceType.setDeviceTypeMetaDefinition(metaDefinition);
         }

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/Feature.java

@@ -39,6 +39,10 @@ public class Feature implements Serializable {
                                                    "Features allow you to perform operations on any device type, " +
                                                    "such as android, iOS or windows..", required = true )
     private String deviceType;
+
+    @ApiModelProperty(name = "pushNotificationProviderType", value = "Provides push notification provider for the " +
+            "feature. If not set default push notification strategy will be used.")
+    private String pushNotificationType;
     
     @ApiModelProperty(name = "metadataEntries", value = "Properties related to features.", required = true )
     private List<MetadataEntry> metadataEntries;
@@ -87,6 +91,15 @@ public class Feature implements Serializable {
         this.deviceType = deviceType;
     }
 
+    @XmlElement
+    public String getPushNotificationType() {
+        return pushNotificationType;
+    }
+
+    public void setPushNotificationType(String pushNotificationType) {
+        this.pushNotificationType = pushNotificationType;
+    }
+
     @XmlElement
     public String getDescription() {
         return description;

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/operation/mgt/OperationManager.java

@@ -25,6 +25,7 @@ import org.wso2.carbon.device.mgt.common.PaginationResult;
 import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * This represents the Device Operation management functionality which should be implemented by
@@ -107,12 +108,23 @@ public interface OperationManager {
      * Operation manger implementation can have a push notification stratergy
      * @param notificationStrategy eg: mqtt/xmpp
      */
-    void setNotificationStrategy(NotificationStrategy notificationStrategy);
+    void setDefaultNotificationStrategy(NotificationStrategy notificationStrategy);
 
     /**
      * retrive the push notification strategy.
      * @return NotificationStrategy
      */
-    NotificationStrategy getNotificationStrategy();
+    NotificationStrategy getDefaultNotificationStrategy();
+
+    /**
+     * Set notification strategy map which contains feature code to notification strategy map
+     * @param notificationStrategyMap
+     */
+    public void setNotificationStrategyMap(Map<String, NotificationStrategy> notificationStrategyMap);
+    /**
+     * Provides notification strategy Map
+     * @return Map which contains mapping for feature code to notification strategy
+     */
+    public Map<String, NotificationStrategy> getNotificationStrategyMap();
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/push/notification/PushNotificationConfig.java

@@ -27,12 +27,15 @@ public class PushNotificationConfig {
 
     private String type;
     private boolean isScheduled;
+    private boolean isDefault;
     Map<String, String> properties;
 
-    public PushNotificationConfig(String type, boolean isScheduled, Map<String, String> properties) {
+    public PushNotificationConfig(String type, boolean isScheduled, boolean isDefault, Map<String, String>
+            properties) {
         this.type = type;
         this.properties = properties;
         this.isScheduled = isScheduled;
+        this.isDefault = isDefault;
     }
 
     @XmlElement(name = "Type", required = true)
@@ -45,6 +48,11 @@ public class PushNotificationConfig {
         return isScheduled;
     }
 
+    @XmlElement(name = "Default")
+    public boolean isDefault() {
+        return isDefault;
+    }
+
     public Map<String, String> getProperties() {
         return properties;
     }

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/spi/DeviceManagementService.java

@@ -24,6 +24,8 @@ import org.wso2.carbon.device.mgt.common.policy.mgt.PolicyMonitoringManager;
 import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubscriber;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
 
+import java.util.List;
+
 /**
  * Composite interface that acts as the SPI exposing all device management as well as application management
  * functionalities.
@@ -42,7 +44,7 @@ public interface DeviceManagementService {
 
     ProvisioningConfig getProvisioningConfig();
 
-    PushNotificationConfig getPushNotificationConfig();
+    List<PushNotificationConfig> getPushNotificationConfigs();
 
     PolicyMonitoringManager getPolicyMonitoringManager();
 

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/type/mgt/DeviceTypeMetaDefinition.java

@@ -2,7 +2,6 @@ package org.wso2.carbon.device.mgt.common.type.mgt;
 
 import org.wso2.carbon.device.mgt.common.Feature;
 import org.wso2.carbon.device.mgt.common.InitialOperationConfig;
-import org.wso2.carbon.device.mgt.common.OperationMonitoringTaskConfig;
 import org.wso2.carbon.device.mgt.common.license.mgt.License;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
 
@@ -13,7 +12,7 @@ public class DeviceTypeMetaDefinition {
     private List<String> properties;
     private List<Feature> features;
     private boolean claimable;
-    private PushNotificationConfig pushNotificationConfig;
+    private List<PushNotificationConfig> pushNotificationConfigs;
     private boolean policyMonitoringEnabled;
     private InitialOperationConfig initialOperationConfig;
     private License license;
@@ -51,13 +50,13 @@ public class DeviceTypeMetaDefinition {
         this.claimable = isClaimable;
     }
 
-    public PushNotificationConfig getPushNotificationConfig() {
+    public List<PushNotificationConfig> getPushNotificationConfigs() {
-        return pushNotificationConfig;
+        return pushNotificationConfigs;
     }
 
-    public void setPushNotificationConfig(
+    public void setPushNotificationConfigs(
-            PushNotificationConfig pushNotificationConfig) {
+            List<PushNotificationConfig> pushNotificationConfigs) {
-        this.pushNotificationConfig = pushNotificationConfig;
+        this.pushNotificationConfigs = pushNotificationConfigs;
     }
 
     public boolean isPolicyMonitoringEnabled() {

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/DeviceManagementPluginRepository.java

@@ -22,13 +22,11 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
-import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubscriber;
+import org.wso2.carbon.device.mgt.common.DeviceStatusTaskPluginConfig;
-import org.wso2.carbon.device.mgt.core.dto.DeviceManagementServiceHolder;
-import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier;
 import org.wso2.carbon.device.mgt.common.OperationMonitoringTaskConfig;
 import org.wso2.carbon.device.mgt.common.ProvisioningConfig;
-import org.wso2.carbon.device.mgt.common.DeviceStatusTaskPluginConfig;
 import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
+import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubscriber;
 import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationProvider;
@@ -37,7 +35,9 @@ import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypeDefinitionProvider;
 import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypeMetaDefinition;
 import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
 import org.wso2.carbon.device.mgt.core.config.DeviceManagementConfig;
+import org.wso2.carbon.device.mgt.core.dto.DeviceManagementServiceHolder;
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
+import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagerStartupListener;
@@ -51,9 +51,12 @@ import org.wso2.carbon.device.mgt.core.task.DeviceMgtTaskException;
 import org.wso2.carbon.device.mgt.core.task.DeviceTaskManagerService;
 import org.wso2.carbon.device.mgt.core.util.DeviceManagerUtil;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class DeviceManagementPluginRepository implements DeviceManagerStartupListener {
 
@@ -155,8 +158,9 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
         OperationManager operationManager = operationManagerRepository.getOperationManager(
                 deviceTypeIdentifier);
         if (operationManager != null) {
-            NotificationStrategy notificationStrategy = operationManager.getNotificationStrategy();
+            Collection<NotificationStrategy> notificationStrategies = operationManager.getNotificationStrategyMap()
-            if (notificationStrategy != null) {
+                    .values();
+            for (NotificationStrategy notificationStrategy : notificationStrategies) {
                 notificationStrategy.undeploy();
             }
             operationManagerRepository.removeOperationManager(deviceTypeIdentifier);
@@ -204,7 +208,7 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
                 long updatedTimestamp = provider.getTimestamp();
                 if (System.currentTimeMillis() - updatedTimestamp > DEFAULT_UPDATE_TIMESTAMP) {
                     try {
-                        DeviceType deviceType = DeviceManagerUtil.getDeviceType(type,tenantId);
+                        DeviceType deviceType = DeviceManagerUtil.getDeviceType(type, tenantId);
                         DeviceTypeMetaDefinition deviceTypeMetaDefinition = deviceType.getDeviceTypeMetaDefinition();
                         if (deviceTypeMetaDefinition != null) {
                             Gson gson = new Gson();
@@ -213,8 +217,9 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
                                     provider.getDeviceManagementService()).getDeviceTypeMetaDefinition();
                             String cachedDefinition = gson.toJson(deviceTypeMetaDefinition);
                             if (!cachedDefinition.equals(dbStoredDefinition)) {
-                                DeviceManagementService deviceTypeManagerService = DeviceManagementDataHolder.getInstance()
+                                DeviceManagementService deviceTypeManagerService = DeviceManagementDataHolder
-                                        .getDeviceTypeGeneratorService().populateDeviceManagementService(type, deviceTypeMetaDefinition);
+                                        .getInstance().getDeviceTypeGeneratorService()
+                                        .populateDeviceManagementService(type, deviceTypeMetaDefinition);
                                 if (deviceTypeManagerService == null) {
                                     log.error("Failing to retrieve the device type service for " + type);
                                     return null;
@@ -248,7 +253,7 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
 
     private void registerPushNotificationStrategy(DeviceManagementService deviceManagementService)
             throws DeviceManagementException {
-        PushNotificationConfig pushNoteConfig = deviceManagementService.getPushNotificationConfig();
+        List<PushNotificationConfig> pushNoteConfigs = deviceManagementService.getPushNotificationConfigs();
         PrivilegedCarbonContext.startTenantFlow();
         PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(
                 deviceManagementService.getProvisioningConfig().getProviderTenantDomain(), true);
@@ -262,17 +267,40 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
                 deviceTypeIdentifier = new DeviceTypeServiceIdentifier(deviceManagementService.getType(), tenantId);
             }
 
-            if (pushNoteConfig != null) {
+            if (pushNoteConfigs != null) {
-                PushNotificationProvider provider = DeviceManagementDataHolder.getInstance()
+                Map<String, NotificationStrategy> notificationStrategyMap = new ConcurrentHashMap<>();
-                        .getPushNotificationProviderRepository().getProvider(pushNoteConfig.getType());
+                NotificationStrategy defaultNotificationStrategy = null;
-                if (provider == null) {
+                for (PushNotificationConfig pushNoteConfig : pushNoteConfigs) {
+                    PushNotificationProvider provider = DeviceManagementDataHolder.getInstance()
+                            .getPushNotificationProviderRepository().getProvider(pushNoteConfig.getType());
+                    if (provider == null) {
+                        throw new DeviceManagementException(
+                                "No registered push notification provider found for the type: '" +
+                                        pushNoteConfig.getType() + "'.");
+                    }
+                    NotificationStrategy notificationStrategy = provider.getNotificationStrategy(pushNoteConfig);
+                    if (pushNoteConfig.isDefault()) {
+                        if (defaultNotificationStrategy == null) {
+                            defaultNotificationStrategy = notificationStrategy;
+                        } else {
+                            throw new DeviceManagementException(
+                                    "Multiple push notification strategies are set as default. Only one strategy can " +
+                                            "be set as default for the device type: '" + deviceTypeIdentifier
+                                            .getDeviceType() + "'.");
+                        }
+                    }
+                    notificationStrategyMap.put(pushNoteConfig.getType(), notificationStrategy);
+                }
+
+                if (defaultNotificationStrategy != null) {
+                    operationManagerRepository.addOperationManager(deviceTypeIdentifier,
+                            new OperationManagerImpl(deviceTypeIdentifier.getDeviceType(),
+                                    defaultNotificationStrategy, notificationStrategyMap));
+                } else {
                     throw new DeviceManagementException(
-                            "No registered push notification provider found for the type: '" +
+                            "No registered default push notification provider found for the device type: '" + deviceTypeIdentifier
-                                    pushNoteConfig.getType() + "'.");
+                                    .getDeviceType() + "'.");
                 }
-                NotificationStrategy notificationStrategy = provider.getNotificationStrategy(pushNoteConfig);
-                operationManagerRepository.addOperationManager(deviceTypeIdentifier,
-                        new OperationManagerImpl(deviceTypeIdentifier.getDeviceType(), notificationStrategy));
             } else {
                 operationManagerRepository.addOperationManager(deviceTypeIdentifier,
                         new OperationManagerImpl(deviceTypeIdentifier.getDeviceType()));
@@ -377,7 +405,7 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
         String deviceTypeName;
         synchronized (providers) {
             for (DeviceManagementServiceHolder deviceManagementServiceHolder : providers.values()) {
-                DeviceManagementService  provider= deviceManagementServiceHolder.getDeviceManagementService();
+                DeviceManagementService provider = deviceManagementServiceHolder.getDeviceManagementService();
                 try {
                     provider.init();
                     deviceTypeName = provider.getType();

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/OperationManagerImpl.java

@@ -25,6 +25,8 @@ import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.Feature;
+import org.wso2.carbon.device.mgt.common.FeatureManager;
 import org.wso2.carbon.device.mgt.common.InvalidDeviceException;
 import org.wso2.carbon.device.mgt.common.MonitoringOperation;
 import org.wso2.carbon.device.mgt.common.PaginationRequest;
@@ -64,6 +66,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
+import java.util.Map;
 
 /**
  * This class implements all the functionality exposed as part of the OperationManager. Any transaction initiated
@@ -82,8 +85,10 @@ public class OperationManagerImpl implements OperationManager {
     private OperationDAO operationDAO;
     private DeviceDAO deviceDAO;
     private EnrollmentDAO enrollmentDAO;
-    private NotificationStrategy notificationStrategy;
+    private Map<String, NotificationStrategy> notificationStrategyMap;
+    private NotificationStrategy defaultNotificationStrategy;
     private String deviceType;
+    private FeatureManager featureManager;
 
     public OperationManagerImpl() {
         commandOperationDAO = OperationManagementDAOFactory.getCommandOperationDAO();
@@ -96,22 +101,35 @@ public class OperationManagerImpl implements OperationManager {
         enrollmentDAO = DeviceManagementDAOFactory.getEnrollmentDAO();
     }
 
-    public OperationManagerImpl(String deviceType) {
+    public OperationManagerImpl(String deviceType) throws DeviceManagementException {
         this();
         this.deviceType = deviceType;
+        featureManager = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider()
+                .getFeatureManager(deviceType);
     }
 
-    public NotificationStrategy getNotificationStrategy() {
+    public NotificationStrategy getDefaultNotificationStrategy() {
-        return notificationStrategy;
+        return defaultNotificationStrategy;
     }
 
-    public void setNotificationStrategy(NotificationStrategy notificationStrategy) {
+    public void setDefaultNotificationStrategy(NotificationStrategy defaultNotificationStrategy) {
-        this.notificationStrategy = notificationStrategy;
+        this.defaultNotificationStrategy = defaultNotificationStrategy;
     }
 
-    public OperationManagerImpl(String deviceType, NotificationStrategy notificationStrategy) {
+    public Map<String, NotificationStrategy> getNotificationStrategyMap() {
+        return notificationStrategyMap;
+    }
+
+    public void setNotificationStrategyMap(Map<String, NotificationStrategy> notificationStrategyMap) {
+        this.notificationStrategyMap = notificationStrategyMap;
+    }
+
+    public OperationManagerImpl(String deviceType, NotificationStrategy defaultNotificationStrategy, Map<String,
+            NotificationStrategy> notificationStrategyMap) throws
+            DeviceManagementException {
         this(deviceType);
-        this.notificationStrategy = notificationStrategy;
+        this.defaultNotificationStrategy = defaultNotificationStrategy;
+        this.notificationStrategyMap = notificationStrategyMap;
     }
 
     @Override
@@ -149,8 +167,17 @@ public class OperationManagerImpl implements OperationManager {
                 boolean isNotRepeated = false;
                 boolean isScheduled = false;
 
+
                 // check whether device list is greater than batch size notification strategy has enable to send push
                 // notification using scheduler task
+                NotificationStrategy notificationStrategy = null;
+                Feature feature = featureManager.getFeature(operation.getCode());
+                if (feature != null && feature.getPushNotificationType() != null) {
+                    notificationStrategy = notificationStrategyMap.get(feature.getPushNotificationType());
+                }
+                if (notificationStrategy == null) {
+                    notificationStrategy = defaultNotificationStrategy;
+                }
                 if (DeviceConfigurationManager.getInstance().getDeviceManagementConfig().
                         getPushNotificationConfiguration().getSchedulerBatchSize() <= authorizedDeviceList.size() &&
                         notificationStrategy != null) {
@@ -197,13 +224,15 @@ public class OperationManagerImpl implements OperationManager {
                             operation.setId(operationId);
                             operation.setActivityId(DeviceManagementConstants.OperationAttributes.ACTIVITY + operationId);
                             notificationStrategy.execute(new NotificationContext(deviceId, operation));
-                            operationMappingDAO.updateOperationMapping(operationId, enrolmentId, org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.PushNotificationStatus.COMPLETED);
+                            operationMappingDAO.updateOperationMapping(operationId, enrolmentId, org.wso2.carbon
+                                    .device.mgt.core.dto.operation.mgt.Operation.PushNotificationStatus.COMPLETED);
                         } catch (PushNotificationExecutionFailedException e) {
                             log.error("Error occurred while sending push notifications to " +
                                       deviceId.getType() + " device carrying id '" +
                                       deviceId + "'", e);
                             // Reschedule if push notification failed.
-                            operationMappingDAO.updateOperationMapping(operationId, enrolmentId, org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.PushNotificationStatus.SCHEDULED);
+                            operationMappingDAO.updateOperationMapping(operationId, enrolmentId, org.wso2.carbon
+                                    .device.mgt.core.dto.operation.mgt.Operation.PushNotificationStatus.SCHEDULED);
                         }
                     }
                 }
@@ -230,6 +259,9 @@ public class OperationManagerImpl implements OperationManager {
             throw new OperationManagementException("Error occurred while adding operation", e);
         } catch (TransactionManagementException e) {
             throw new OperationManagementException("Error occurred while initiating the transaction", e);
+        } catch (DeviceManagementException e) {
+            throw new OperationManagementException("Error occurred while getting feature for given operation code :"
+                    + operation.getCode(), e);
         } finally {
             OperationManagementDAOFactory.closeConnection();
         }
@@ -242,7 +274,7 @@ public class OperationManagerImpl implements OperationManager {
         //Add the invalid DeviceIds
         for (String id : deviceIdValidationResult.getErrorDeviceIdList()) {
             activityStatus = new ActivityStatus();
-            activityStatus.setDeviceIdentifier(new DeviceIdentifier(id,deviceType));
+            activityStatus.setDeviceIdentifier(new DeviceIdentifier(id, deviceType));
             activityStatus.setStatus(ActivityStatus.Status.INVALID);
             activityStatuses.add(activityStatus);
         }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/push/notification/mgt/PushNotificationBasedOperationManager.java

@@ -28,6 +28,7 @@ import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationExecutionFailedException;
 
 import java.util.List;
+import java.util.Map;
 
 public class PushNotificationBasedOperationManager implements OperationManager {
 
@@ -142,13 +143,24 @@ public class PushNotificationBasedOperationManager implements OperationManager {
     }
 
     @Override
-    public void setNotificationStrategy(NotificationStrategy notificationStrategy) {
+    public void setDefaultNotificationStrategy(NotificationStrategy notificationStrategy) {
 
     }
 
     @Override
-    public NotificationStrategy getNotificationStrategy() {
+    public NotificationStrategy getDefaultNotificationStrategy() {
-        return notificationProvider;
+        return null;
     }
 
+    @Override
+    public void setNotificationStrategyMap(Map<String, NotificationStrategy> notificationStrategyMap) {
+
+    }
+
+    @Override
+    public Map<String, NotificationStrategy> getNotificationStrategyMap() {
+        return null;
+    }
+
+
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/push/notification/mgt/task/PushNotificationSchedulerTask.java

@@ -21,6 +21,8 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
+import org.wso2.carbon.device.mgt.common.Feature;
+import org.wso2.carbon.device.mgt.common.FeatureManager;
 import org.wso2.carbon.device.mgt.common.TransactionManagementException;
 import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
 import org.wso2.carbon.device.mgt.common.push.notification.NotificationContext;
@@ -83,12 +85,24 @@ public class PushNotificationSchedulerTask implements Runnable {
                         PrivilegedCarbonContext.startTenantFlow();
                         PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(operationMapping.getTenantId(), true);
                         // Get notification strategy for given device type
-                        NotificationStrategy notificationStrategy = provider.getNotificationStrategyByDeviceType
+                        NotificationStrategy notificationStrategy = null;
-                                (operationMapping.getDeviceIdentifier().getType());
+                        org.wso2.carbon.device.mgt.common.operation.mgt.Operation operation = provider.getOperation(operationMapping.getDeviceIdentifier().getType(), operationMapping
+                                .getOperationId());
+                        FeatureManager featureManager = provider.getFeatureManager(operationMapping.getDeviceIdentifier().getType());
+                        Feature feature = featureManager.getFeature(operation.getCode());
+                        if (feature != null) {
+                            Map<String, NotificationStrategy> notificationStrategyListByDeviceType = provider.getNotificationStrategyListByDeviceType(operationMapping.getDeviceIdentifier().getType());
+                            if (notificationStrategyListByDeviceType != null && feature.getPushNotificationType() != null) {
+                                notificationStrategy = notificationStrategyListByDeviceType.get(feature.getPushNotificationType());
+                            }
+                        }
+                        if (notificationStrategy == null) {
+                            notificationStrategy = provider.getDefaultNotificationStrategyByDeviceType(operationMapping.getDeviceIdentifier()
+                                    .getType());
+                        }
                         // Send the push notification on given strategy
                         notificationStrategy.execute(new NotificationContext(operationMapping.getDeviceIdentifier(),
-                                provider.getOperation(operationMapping.getDeviceIdentifier().getType(), operationMapping
+                                operation));
-                                        .getOperationId())));
                         operationMapping.setPushNotificationStatus(Operation.PushNotificationStatus.COMPLETED);
                         operationsCompletedList.add(operationMapping);
                     } catch (DeviceManagementException e) {

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderService.java

@@ -39,7 +39,9 @@ import org.wso2.carbon.device.mgt.core.dto.DeviceType;
 
 import java.util.Date;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Proxy class for all Device Management related operations that take the corresponding plugin type in
@@ -471,7 +473,10 @@ public interface DeviceManagementProviderService {
      * @return Notification Strategy for device type
      * @throws DeviceManagementException
      */
-    NotificationStrategy getNotificationStrategyByDeviceType(String deviceType) throws DeviceManagementException;
+    NotificationStrategy getDefaultNotificationStrategyByDeviceType(String deviceType) throws DeviceManagementException;
+
+    Map<String, NotificationStrategy> getNotificationStrategyListByDeviceType(String deviceType) throws
+            DeviceManagementException;
 
     License getLicense(String deviceType, String languageCode) throws DeviceManagementException;
 

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderServiceImpl.java

@@ -28,9 +28,6 @@ import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.DeviceManager;
 import org.wso2.carbon.device.mgt.common.DeviceNotFoundException;
-import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationExecutionFailedException;
-import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubscriber;
-import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier;
 import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
 import org.wso2.carbon.device.mgt.common.FeatureManager;
 import org.wso2.carbon.device.mgt.common.InitialOperationConfig;
@@ -55,6 +52,8 @@ 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.common.operation.mgt.OperationManager;
 import org.wso2.carbon.device.mgt.common.policy.mgt.PolicyMonitoringManager;
+import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationExecutionFailedException;
+import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubscriber;
 import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
 import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
@@ -69,6 +68,7 @@ import org.wso2.carbon.device.mgt.core.dao.EnrollmentDAO;
 import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsDAO;
 import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsMgtDAOException;
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
+import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.device.mgt.core.internal.PluginInitializationListener;
@@ -1428,11 +1428,24 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
     }
 
     @Override
-    public NotificationStrategy getNotificationStrategyByDeviceType(String deviceType) throws DeviceManagementException {
+    public NotificationStrategy getDefaultNotificationStrategyByDeviceType(String deviceType) throws
+            DeviceManagementException {
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        OperationManager operationManager = pluginRepository.getOperationManager(deviceType, tenantId);
+        if (operationManager != null) {
+            return operationManager.getDefaultNotificationStrategy();
+        } else {
+            throw new DeviceManagementException("Cannot find operation manager for given device type :" + deviceType);
+        }
+    }
+
+    @Override
+    public Map<String, NotificationStrategy> getNotificationStrategyListByDeviceType(String deviceType) throws
+            DeviceManagementException {
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
         OperationManager operationManager = pluginRepository.getOperationManager(deviceType, tenantId);
         if (operationManager != null) {
-            return operationManager.getNotificationStrategy();
+            return operationManager.getNotificationStrategyMap();
         } else {
             throw new DeviceManagementException("Cannot find operation manager for given device type :" + deviceType);
         }
@@ -1662,8 +1675,8 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
         DeviceManagementService dms =
                 pluginRepository.getDeviceManagementService(deviceIdentifier.getType(), this.getTenantId());
         if (dms == null) {
-            String message = "Device type '" + deviceIdentifier.getType() + "' does not have an associated device management " +
+            String message = "Device type '" + deviceIdentifier.getType() + "' does not have an associated device " +
-                    "plugin registered within the framework";
+                    "management " + "plugin registered within the framework";
             if (log.isDebugEnabled()) {
                 log.debug(message);
             }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/TestDeviceManagementService.java

@@ -24,6 +24,8 @@ import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubsc
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
 import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
 
+import java.util.List;
+
 public class TestDeviceManagementService implements DeviceManagementService {
 
     private String providerType;
@@ -63,8 +65,7 @@ public class TestDeviceManagementService implements DeviceManagementService {
         return new ProvisioningConfig(tenantDomain, false);
     }
 
-    @Override
+    public List<PushNotificationConfig> getPushNotificationConfigs() {
-    public PushNotificationConfig getPushNotificationConfig() {
         return null;
     }
 

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/DeviceTypeManagerService.java

@@ -22,10 +22,10 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.DeviceManager;
+import org.wso2.carbon.device.mgt.common.DeviceStatusTaskPluginConfig;
 import org.wso2.carbon.device.mgt.common.InitialOperationConfig;
 import org.wso2.carbon.device.mgt.common.MonitoringOperation;
 import org.wso2.carbon.device.mgt.common.OperationMonitoringTaskConfig;
-import org.wso2.carbon.device.mgt.common.DeviceStatusTaskPluginConfig;
 import org.wso2.carbon.device.mgt.common.ProvisioningConfig;
 import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManager;
 import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationEntry;
@@ -42,12 +42,14 @@ import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PolicyM
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Property;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PullNotificationSubscriberConfig;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PushNotificationProvider;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PushNotificationProviders;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.TaskConfiguration;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.policy.mgt.DefaultPolicyMonitoringManager;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.pull.notification.PullNotificationSubscriberLoader;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -60,7 +62,7 @@ public class DeviceTypeManagerService implements DeviceManagementService {
     private static final Log log = LogFactory.getLog(DeviceTypeManagerService.class);
 
     private DeviceManager deviceManager;
-    private PushNotificationConfig pushNotificationConfig;
+    private List<PushNotificationConfig> pushNotificationConfigs;
     private ProvisioningConfig provisioningConfig;
     private String type;
     private OperationMonitoringTaskConfig operationMonitoringConfigs;
@@ -75,7 +77,7 @@ public class DeviceTypeManagerService implements DeviceManagementService {
         this.setProvisioningConfig(deviceTypeConfigIdentifier.getTenantDomain(), deviceTypeConfiguration);
         this.deviceManager = new DeviceTypeManager(deviceTypeConfigIdentifier, deviceTypeConfiguration);
         this.setType(deviceTypeConfiguration.getName());
-        this.populatePushNotificationConfig(deviceTypeConfiguration.getPushNotificationProvider());
+        this.populatePushNotificationConfig(deviceTypeConfiguration.getPushNotificationProviders());
         this.operationMonitoringConfigs = new OperationMonitoringTaskConfig();
         this.setOperationMonitoringConfig(deviceTypeConfiguration);
         this.initialOperationConfig = new InitialOperationConfig();
@@ -92,7 +94,7 @@ public class DeviceTypeManagerService implements DeviceManagementService {
     }
 
     @Override
-    public OperationMonitoringTaskConfig getOperationMonitoringConfig(){
+    public OperationMonitoringTaskConfig getOperationMonitoringConfig() {
         return operationMonitoringConfigs;
     }
 
@@ -120,35 +122,42 @@ public class DeviceTypeManagerService implements DeviceManagementService {
     public void init() throws DeviceManagementException {
     }
 
-    private void populatePushNotificationConfig(PushNotificationProvider pushNotificationProvider) {
+    private void populatePushNotificationConfig(PushNotificationProviders pushNotificationProviders) {
-        if (pushNotificationProvider != null) {
+        if (pushNotificationProviders != null) {
-            if (pushNotificationProvider.isFileBasedProperties()) {
+            pushNotificationConfigs = new LinkedList<>();
-                Map<String, String> staticProps = new HashMap<>();
+            List<PushNotificationProvider> notificationProviders = pushNotificationProviders.getPushNotificationProviders();
-                ConfigProperties configProperties = pushNotificationProvider.getConfigProperties();
+            for (PushNotificationProvider pushNotificationProvider : notificationProviders) {
-                if (configProperties != null) {
+                if (pushNotificationProvider != null) {
-                    List<Property> properties = configProperties.getProperty();
+                    if (pushNotificationProvider.isFileBasedProperties()) {
-                    if (properties != null && properties.size() > 0) {
+                        Map<String, String> staticProps = new HashMap<>();
-                        for (Property property : properties) {
+                        ConfigProperties configProperties = pushNotificationProvider.getConfigProperties();
-                            staticProps.put(property.getName(), property.getValue());
+                        if (configProperties != null) {
+                            List<Property> properties = configProperties.getProperty();
+                            if (properties != null && properties.size() > 0) {
+                                for (Property property : properties) {
+                                    staticProps.put(property.getName(), property.getValue());
+                                }
+                            }
                         }
-                    }
+                        pushNotificationConfigs.add(new PushNotificationConfig(pushNotificationProvider.getType(),
-                }
+                                pushNotificationProvider.isScheduled(), pushNotificationProvider.isDefault(), staticProps));
-                pushNotificationConfig = new PushNotificationConfig(pushNotificationProvider.getType(),
+                    } else {
-                        pushNotificationProvider.isScheduled(), staticProps);
+                        try {
-            } else {
+                            PlatformConfiguration deviceTypeConfig = deviceManager.getConfiguration();
-                try {
+                            if (deviceTypeConfig != null) {
-                    PlatformConfiguration deviceTypeConfig = deviceManager.getConfiguration();
+                                List<ConfigurationEntry> configuration = deviceTypeConfig.getConfiguration();
-                    if (deviceTypeConfig != null) {
+                                if (configuration.size() > 0) {
-                        List<ConfigurationEntry> configuration = deviceTypeConfig.getConfiguration();
+                                    Map<String, String> properties = this.getConfigProperty(configuration);
-                        if (configuration.size() > 0) {
+                                    pushNotificationConfigs.add(new PushNotificationConfig(
-                            Map<String, String> properties = this.getConfigProperty(configuration);
+                                            pushNotificationProvider.getType(), pushNotificationProvider.isScheduled(),
-                            pushNotificationConfig = new PushNotificationConfig(
+                                            pushNotificationProvider.isDefault(),
-                                    pushNotificationProvider.getType(), pushNotificationProvider.isScheduled(),
+                                            properties));
-                                    properties);
+                                }
+                            }
+                        } catch (DeviceManagementException e) {
+                            log.error("Unable to get the " + type + " platform configuration from registry.");
                         }
                     }
-                } catch (DeviceManagementException e) {
-                    log.error("Unable to get the " + type + " platform configuration from registry.");
                 }
             }
         }
@@ -169,9 +178,8 @@ public class DeviceTypeManagerService implements DeviceManagementService {
         return provisioningConfig;
     }
 
-    @Override
+    public List<PushNotificationConfig> getPushNotificationConfigs() {
-    public PushNotificationConfig getPushNotificationConfig() {
+        return pushNotificationConfigs;
-        return pushNotificationConfig;
     }
 
     @Override

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/HTTPDeviceTypeManagerService.java

@@ -29,15 +29,16 @@ import org.wso2.carbon.device.mgt.extensions.device.type.template.config.ConfigP
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceDetails;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Features;
-import org.wso2.carbon.device.mgt.extensions.device.type.template.config.License;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PolicyMonitoring;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Properties;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Property;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.ProvisioningConfig;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PullNotificationSubscriberConfig;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PushNotificationProvider;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PushNotificationProviders;
 
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -84,6 +85,7 @@ public class HTTPDeviceTypeManagerService extends DeviceTypeManagerService imple
                         configFeature.setCode(feature.getCode());
                         configFeature.setDescription(feature.getDescription());
                         configFeature.setName(feature.getName());
+                        configFeature.setPushNotificationType(feature.getPushNotificationType());
                         if (feature.getMetadataEntries() != null && feature.getMetadataEntries().size() > 0) {
                             List<String> metaValues = new ArrayList<>();
                             for (Feature.MetadataEntry metadataEntry : feature.getMetadataEntries()) {
@@ -115,29 +117,37 @@ public class HTTPDeviceTypeManagerService extends DeviceTypeManagerService imple
             provisioningConfig.setSharedWithAllTenants(false);
             deviceTypeConfiguration.setProvisioningConfig(provisioningConfig);
 
-            PushNotificationConfig pushNotificationConfig = deviceTypeMetaDefinition.getPushNotificationConfig();
+            List<PushNotificationConfig> pushNotificationConfigs = deviceTypeMetaDefinition
-            if (pushNotificationConfig != null) {
+                    .getPushNotificationConfigs();
-                PushNotificationProvider pushNotificationProvider = new PushNotificationProvider();
+            if (pushNotificationConfigs != null) {
-                pushNotificationProvider.setType(pushNotificationConfig.getType());
+                List<PushNotificationProvider> pushNotificationProviderList = new LinkedList<>();
-                //default schedule value will be true.
+                PushNotificationProviders pushNotificationProviders = new PushNotificationProviders();
-                pushNotificationProvider.setScheduled(true);
+                for (PushNotificationConfig pushNotificationConfig : pushNotificationConfigs) {
-                if (pushNotificationConfig.getProperties() != null &&
+                    PushNotificationProvider pushNotificationProvider = new PushNotificationProvider();
-                        pushNotificationConfig.getProperties().size() > 0) {
+                    pushNotificationProvider.setType(pushNotificationConfig.getType());
-                    ConfigProperties configProperties = new ConfigProperties();
+                    //default schedule value will be true.
-                    List<Property> properties = new ArrayList<>();
+                    pushNotificationProvider.setScheduled(true);
-                    for (Map.Entry<String, String> entry : pushNotificationConfig.getProperties().entrySet()) {
+                    if (pushNotificationConfig.getProperties() != null &&
-                        Property property = new Property();
+                            pushNotificationConfig.getProperties().size() > 0) {
-                        property.setName(entry.getKey());
+                        ConfigProperties configProperties = new ConfigProperties();
-                        property.setValue(entry.getValue());
+                        List<Property> properties = new ArrayList<>();
-                        properties.add(property);
+                        for (Map.Entry<String, String> entry : pushNotificationConfig.getProperties().entrySet()) {
+                            Property property = new Property();
+                            property.setName(entry.getKey());
+                            property.setValue(entry.getValue());
+                            properties.add(property);
+                        }
+                        configProperties.addProperties(properties);
+                        pushNotificationProvider.setConfigProperties(configProperties);
                     }
-                    configProperties.addProperties(properties);
+                    pushNotificationProvider.setFileBasedProperties(true);
-                    pushNotificationProvider.setConfigProperties(configProperties);
+                    pushNotificationProviderList.add(pushNotificationProvider);
                 }
-                pushNotificationProvider.setFileBasedProperties(true);
+                pushNotificationProviders.addPushNotificationProviders(pushNotificationProviderList);
-                deviceTypeConfiguration.setPushNotificationProvider(pushNotificationProvider);
+                deviceTypeConfiguration.setPushNotificationProviders(pushNotificationProviders);
             }
 
+
 //            This is commented until the task registration handling issue is solved
 //            OperationMonitoringTaskConfig operationMonitoringTaskConfig = deviceTypeMetaDefinition.getTaskConfig();
 //            if (operationMonitoringTaskConfig != null) {

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/config/DeviceTypeConfiguration.java

@@ -41,6 +41,7 @@ import java.util.List;
  *         <element name="Features" type="{}Features"/>
  *         <element name="ProvisioningConfig" type="{}ProvisioningConfig"/>
  *         <element name="PushNotificationProviderConfig" type="{}PushNotificationProviderConfig"/>
+ *         <element name="PullNotificationSubscriberConfig" type="{}PullNotificationSubscriberConfig"/>
  *         <element name="License" type="{}License"/>
  *         <element name="DataSource" type="{}DataSource"/>
  *         <element name="PolicyMonitoring" type="{}PolicyMonitoring"/>
@@ -65,8 +66,8 @@ public class DeviceTypeConfiguration {
     protected Features features;
     @XmlElement(name = "ProvisioningConfig", required = true)
     protected ProvisioningConfig provisioningConfig;
-    @XmlElement(name = "PushNotificationProviderConfig", required = true)
+    @XmlElement(name = "PushNotificationProviderConfigs", required = true)
-    protected PushNotificationProvider pushNotificationProvider;
+    protected PushNotificationProviders pushNotificationProviders;
     @XmlElement(name = "PullNotificationSubscriberConfig", required = true)
     protected PullNotificationSubscriberConfig pullNotificationSubscriberConfig;
     @XmlElement(name = "License", required = true)
@@ -245,23 +246,23 @@ public class DeviceTypeConfiguration {
     }
 
     /**
-     * Gets the value of the pushNotificationProvider property.
+     * Gets the value of the pushNotificationProviders property.
      *
      * @return possible object is
      * {@link PushNotificationProvider }
      */
-    public PushNotificationProvider getPushNotificationProvider() {
+    public PushNotificationProviders getPushNotificationProviders() {
-        return pushNotificationProvider;
+        return pushNotificationProviders;
     }
 
     /**
-     * Sets the value of the pushNotificationProvider property.
+     * Sets the value of the pushNotificationProviders property.
      *
      * @param value allowed object is
      *              {@link PushNotificationProvider }
      */
-    public void setPushNotificationProvider(PushNotificationProvider value) {
+    public void setPushNotificationProviders(PushNotificationProviders value) {
-        this.pushNotificationProvider = value;
+        this.pushNotificationProviders = value;
     }
 
     /**

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/config/Feature.java

@@ -42,6 +42,7 @@ import java.util.List;
  *         <element name="Operation" type="{}Operation"/>
  *       </sequence>
  *       <attribute name="code" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="pushNotificationType" type="{http://www.w3.org/2001/XMLSchema}string" />
  *     </restriction>
  *   </complexContent>
  * </complexType>
@@ -68,6 +69,8 @@ public class Feature {
     @XmlElementWrapper(name = "MetaData")
     @XmlElement(name = "Property", required = true)
     protected List<String> metaData;
+    @XmlAttribute(name = "pushNotificationType")
+    protected String pushNotificationType;
 
     /**
      * Gets the value of the name property.
@@ -172,4 +175,28 @@ public class Feature {
     public void setMetaData(List<String> metaData) {
         this.metaData = metaData;
     }
+
+    /**
+     * Gets the value of the pushNotificationType property.
+     *
+     * @return
+     *     possible object is
+     *     {@link String }
+     *
+     */
+    public String getPushNotificationType() {
+        return pushNotificationType;
+    }
+
+    /**
+     * Sets the value of the pushNotificationType property.
+     *
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *
+     */
+    public void setPushNotificationType(String value) {
+        this.pushNotificationType = value;
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/config/PushNotificationProvider.java

@@ -39,6 +39,8 @@ import javax.xml.bind.annotation.XmlType;
  *         <element name="ConfigProperties" type="{}ConfigProperties"/>
  *       </sequence>
  *       <attribute name="type" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="isScheduled" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="default" type="{http://www.w3.org/2001/XMLSchema}string" />
  *     </restriction>
  *   </complexContent>
  * </complexType>
@@ -61,6 +63,8 @@ public class PushNotificationProvider {
     protected String type;
     @XmlAttribute(name = "isScheduled")
     protected boolean isScheduled;
+    @XmlAttribute(name = "default")
+    protected boolean isDefault;
 
     /**
      * Gets the value of the fileBasedProperties property.
@@ -152,4 +156,30 @@ public class PushNotificationProvider {
     public void setScheduled(boolean scheduled) {
         isScheduled = scheduled;
     }
+
+    /**
+     * Gets the value of the isDefault property.
+     * This property will be used to determine whether the given push notification will be used as Default for
+     * features which do not have push notification provider config
+     *
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *
+     */
+    public boolean isDefault() {
+        return isDefault;
+    }
+
+    /**
+     * Sets the value of the isDefault property.
+     *
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *
+     */
+    public void setDefault(boolean isDefault) {
+        isScheduled = isDefault;
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/config/PushNotificationProviders.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2017, 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.device.mgt.extensions.device.type.template.config;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>Java class for PushNotificationProviders complex type.
+ *
+ * <p>The following schema fragment specifies the expected content contained within this class.
+ *
+ * <pre>
+ * &lt;complexType name="PushNotificationProviders">
+ *   &lt;complexContent>
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       &lt;sequence>
+ *         &lt;element name="PushNotificationProvider" type="{}PushNotificationProvider"/>
+ *       &lt;/sequence>
+ *     &lt;/restriction>
+ *   &lt;/complexContent>
+ * &lt;/complexType>
+ * </pre>
+ *
+ *
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "PushNotificationProviders", propOrder = {
+        "pushNotificationProviders"
+})
+public class PushNotificationProviders {
+
+    @XmlElement(name = "PushNotificationProviderConfig")
+    protected List<PushNotificationProvider> pushNotificationProviders;
+
+    /**
+     * Gets the value of the pushNotificationProviders property.
+     *
+     * @return
+     *     possible object is
+     *     {@link PushNotificationProvider }
+     *
+     */
+    public List<PushNotificationProvider> getPushNotificationProviders() {
+        if (pushNotificationProviders == null) {
+            pushNotificationProviders = new ArrayList<PushNotificationProvider>();
+        }
+        return this.pushNotificationProviders;
+    }
+
+    public void addPushNotificationProviders(List<PushNotificationProvider> pushNotificationProviders) {
+        this.pushNotificationProviders = pushNotificationProviders;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/feature/ConfigurationBasedFeatureManager.java

@@ -50,6 +50,7 @@ public class ConfigurationBasedFeatureManager implements FeatureManager {
             deviceFeature.setCode(feature.getCode());
             deviceFeature.setName(feature.getName());
             deviceFeature.setDescription(feature.getDescription());
+            deviceFeature.setPushNotificationType(feature.getPushNotificationType());
             Operation operation = feature.getOperation();
             List<Feature.MetadataEntry> metadataEntries = null;
             if (feature.getMetaData() != null) {