DS method to activate this component.
Best practice: this should be a protected method, not public or private

@param properties : Map containing service & config properties
populated/provided by config admin
974794
@Activate
    protected void activate(Map<String, Object> properties) {
        final String methodName = "activate";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, "Entry Count: " + ++JDBCMBeanRuntime.counterActivate);
        if (trace && tc.isEventEnabled())
            Tr.event(tc, className + methodName, properties);
        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, "Normal Exit");

    }
448303
@Override
    public void activate(ComponentContext context,
                         Map<String, Object> properties, ConfigurationAdmin configAdmin) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, "activate", new Object[] { context, properties,
                                                      configAdmin });
        }
        try {
            // set ME state to starting
            _state = ME_STATE.STARTING.toString();

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                SibTr.debug(this, tc, "Starting the JMS server.");
            }

            // initilize config object
            initialize(context, properties, configAdmin);

            _jsMainImpl = new JsMainImpl(context.getBundleContext());
            _jsMainImpl.initialize(jsMEConfig);
            _jsMainImpl.start();

            // If its here it means all the components have started hence set
            // the state to STARTED
            _state = ME_STATE.STARTED.toString();
            SibTr.info(tc, "ME_STARTED_SIAS0108");
        } catch (InvalidFileStoreConfigurationException ifs) {
            // since there is exception in starting ME the state is set to
            // STOPPED
            _state = ME_STATE.STOPPED.toString();

            SibTr.error(tc, "ME_STOPPED_SIAS0109");
            SibTr.exception(tc, ifs);
            FFDCFilter.processException(ifs,
                                        "com.ibm.ws.messaging.service.JsMainAdminServiceImpl",
                                        "132", this);
        } catch (Exception e) {
            // since there is exception in starting ME the state is set to
            // STOPPED
            _state = ME_STATE.STOPPED.toString();

            SibTr.error(tc, "ME_STOPPED_SIAS0109");
            SibTr.exception(tc, e);
            FFDCFilter.processException(e,
                                        "com.ibm.ws.messaging.service.JsMainAdminServiceImpl",
                                        "139", this);

        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, "activate");
        }
    }
496206
@Activate
    protected void activate(Map<String, Object> properties) throws Exception {
        this.host = (String) properties.get("host");
        Integer iiopPort = (Integer) properties.get("iiopPort");
        this.iiopPort = iiopPort == null ? -1 : iiopPort;

        iiopsOptions = Nester.nest("iiopsOptions", properties);
    }
288772
@Activate
    protected void activate(ComponentContext cContext, Map<String, Object> properties) throws Exception {
        this.cContext = cContext;
        globalHandlerServiceSR.activate(cContext);
        listener = new JaxRSGlobalHandlerBusListener();
        LibertyApplicationBusFactory.getInstance().registerApplicationBusListener(listener);
    }
512598
protected synchronized void activate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Activating");
        }
        bContext = context.getBundleContext();
        instance.set(this);

        sslConfigs.activate(context);
        cfwBundle.getFramework().registerFactories(this);
    }
469270
public void setProperties(Map<String, Object> properties)
    {
        this.properties.clear();
        this.properties.putAll(properties);
    }
566774
@Modified
    protected void modify(ComponentContext cc, Map<String, Object> properties) {
        SibTr.entry(tc, CLASS_NAME + "modify", properties);

        this.properties = properties;
        populateDestinationPermissions();
        runtimeSecurityService.modifyMessagingServices(this);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, CLASS_NAME + "modify");
        }
    }
641832
private void setProperties(Dictionary<String, ?> d) {
        if (d == null) {
            this.properties = null;
            return;
        }

        ConfigurationDictionary newDictionary = new ConfigurationDictionary();
        Enumeration<String> keys = d.keys();
        while (keys.hasMoreElements()) {
            String key = keys.nextElement();
            if (newDictionary.get(key) == null) {
                Object value = d.get(key);
                if (value.getClass().isArray()) {
                    int arrayLength = Array.getLength(value);
                    Object copyOfArray = Array.newInstance(value.getClass().getComponentType(), arrayLength);
                    System.arraycopy(value, 0, copyOfArray, 0, arrayLength);
                    newDictionary.put(key, copyOfArray);
                } else if (value instanceof Collection) {
                    newDictionary.put(key, new Vector<Object>((Collection<?>) value));
                } else {
                    newDictionary.put(key, value);
                }
            } else
                throw new IllegalArgumentException(key + " is already present or is a case variant."); //$NON-NLS-1$
        }

        // fill in necessary properties
        if (this.factoryPid != null) {
            newDictionary.put(ConfigurationAdmin.SERVICE_FACTORYPID, this.factoryPid);
        }
        newDictionary.put(Constants.SERVICE_PID, this.pid);
        if (this.inOverridesFile) {
            newDictionary.put("config.overrides", "true");
        }

        this.properties = newDictionary;

        //we got new props so we should redo the mappings in case they changed
        addPidMapping();
    }
506682
public void doRun(Properties properties) {
        ServerSetup[] serverSetup = new PropertiesBasedServerSetupBuilder().build(properties);

        if (serverSetup.length == 0) {
            printUsage(System.out);

        } else {
            greenMail = new GreenMail(serverSetup);
            log.info("Starting GreenMail standalone v{} using {}",
                    BuildInfo.INSTANCE.getProjectVersion(), Arrays.toString(serverSetup));
            greenMail.withConfiguration(new PropertiesBasedGreenMailConfigurationBuilder().build(properties))
                    .start();
        }
    }
1370028
public void activate(Map<String, Object> properties, ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "activate");
        chfwRef.activate(context);
        _commonServiceFacadeRef.activate(context);
        alarmManagerRef.activate(context);
        exeServiceRef.activate(context);

        getChannelFramewrok().registerFactory("JFapChannelOutbound", JFapChannelFactory.class);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "activate");
    }
923963
public void setProperties(Collection<String> properties) {
        if (null == this.properties) {
            this.properties = new ArrayList<>();
        }
        this.properties.clear();
        this.properties.addAll(properties);
    }
583525
public void activate() {
		deactivate();

		registrations.add(service.getGeometryEditService().addGeometryEditStartHandler(new GeometryEditStartHandler() {

			public void onGeometryEditStart(GeometryEditStartEvent event) {
				cleanup();
			}
		}));
		registrations.add(service.getGeometryEditService().addGeometryEditStopHandler(new GeometryEditStopHandler() {

			public void onGeometryEditStop(GeometryEditStopEvent event) {
				cleanup();
			}
		}));
		registrations.add(service.getGeometryEditService().addGeometryEditShapeChangedHandler(
				new GeometryEditShapeChangedHandler() {

					public void onGeometryShapeChanged(GeometryEditShapeChangedEvent event) {
						fetchGeometries();
					}
				}));
		registrations.add(mapWidget.getMapModel().getMapView().addMapViewChangedHandler(new MapViewChangedHandler() {

			public void onMapViewChanged(MapViewChangedEvent event) {
				for (int i = 0; i < centroids.size(); i++) {
					Coordinate centroid = centroids.get(i);
					Coordinate position = mapWidget.getMapModel().getMapView().getWorldViewTransformer()
							.worldToView(centroid);
					int x = (int) (position.getX() - labelWidth / 2);
					int y = (int) (position.getY() - labelHeight / 2);

					Rectangle rectangle = labelBgs.get(i);
					rectangle.setBounds(new Bbox(x, y, labelWidth, labelHeight));
					mapWidget.render(rectangle, RenderGroup.SCREEN, RenderStatus.UPDATE);

					Text text = labelTxts.get(i);
					text.setPosition(new Coordinate(x + 4, y + 2));
					mapWidget.render(text, RenderGroup.SCREEN, RenderStatus.UPDATE);
				}
			}
		}));
	}
147294
public void setConfigurationProperties(java.util.Collection<SdkConfigurationProperty> configurationProperties) {
        if (configurationProperties == null) {
            this.configurationProperties = null;
            return;
        }

        this.configurationProperties = new java.util.ArrayList<SdkConfigurationProperty>(configurationProperties);
    }
200079
function Map (properties) {
		ok.Data.apply(this, arguments);
		var defaults = this.getDefaults();
		if (!this.properties) {
			this.properties = {};
		}
		if (defaults) {
			this.initProperties(defaults);
		}
		if (properties) {
			this.setMap(properties);
		}
	}
544108
public void into(Properties properties) {
        for (String name : this.properties.stringPropertyNames()) {
            properties.setProperty(name, this.properties.getProperty(name));
        }
    }
260392
@Trivial
    protected void activate(ComponentContext componentContext) {
        Dictionary<String, ?> properties = componentContext.getProperties();
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(this, tc, "activate", properties);

        contextSvcRef.activate(componentContext);

        String jndiName = (String) properties.get(JNDI_NAME);
        name = jndiName == null ? (String) properties.get(CONFIG_ID) : jndiName;

        defaultExecutionProperties = new TreeMap<String, String>();
        defaultExecutionProperties.put(WSContextService.DEFAULT_CONTEXT, WSContextService.UNCONFIGURED_CONTEXT_TYPES);
        defaultExecutionProperties.put(WSContextService.TASK_OWNER, name);

        createDaemonThreads = (Boolean) properties.get(CREATE_DAEMON_THREADS);
        defaultPriority = (Integer) properties.get(DEFAULT_PRIORITY);
        Integer maxPriority = (Integer) properties.get(MAX_PRIORITY);
        threadGroup = AccessController.doPrivileged(new CreateThreadGroupAction(name + " Thread Group", maxPriority), threadGroupTracker.serverAccessControlContext);

        if (trace && tc.isEntryEnabled())
            Tr.exit(this, tc, "activate");
    }
63429
public void setValue(Properties properties)  {
        if (properties == null) {
            throw new IllegalArgumentException("properties must not be null");
        }
        if (type == null) {
            type = ItemType.PROPERTIES;
        }
        if (!isMappableType()) {
            throw new IllegalArgumentException("The type of this item must be 'properties' or 'map'");
        }
        tokensMap = new LinkedHashMap<>();
        for (String key : properties.stringPropertyNames()) {
            Object o = properties.get(key);
            if (o instanceof Token[]) {
                tokensMap.put(key, (Token[])o);
            } else if (o instanceof Token) {
                Token[] tokens = new Token[] { (Token)o };
                tokensMap.put(key, tokens);
            } else {
                Token[] tokens = TokenParser.makeTokens(o.toString(), isTokenize());
                putValue(name, tokens);
            }
        }
    }