Activate this component.

@param ctxt
5092
protected void activate(ComponentContext ctxt) {
        this.bundle = ctxt.getUsingBundle();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Activating for bundle " + this.bundle);
        }

        this.localServlets = new HashSet<Servlet>();
        this.localFilters = new HashSet<Filter>();

        this.contextManager = new ServletContextManager(this.bundle, ctxt.getProperties());
    }
1100582
@Trivial
    protected void activate(ComponentContext context) throws Exception {
        Dictionary<String, ?> props = context.getProperties();
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "activate", props);

        resourceAdapterID = (String) props.get("id");
        contextProviders.activate(context);
        bvalRef.activate(context);
        tranInflowManagerRef.activate(context);
        tranSyncRegistryRef.activate(context);
        jcaSecurityContextRef.activate(context);
        componentContext = context;
        properties = props;
        raMetaData = resourceAdapterSvc.getResourceAdapterMetaData();
        myAppName = raMetaData != null ? raMetaData.getJ2EEName().getApplication() : null;

        Object svc = bvalRef.getService();
        if (svc != null) {
            // Isolate and dynamic load BeanValidationHelpImpl class to avoid javax.validation bundle dependency
            //  when beanValidation feature is not deployed.
            if (System.getSecurityManager() == null)
                bvalHelper = (BeanValidationHelper) componentContext.getBundleContext().getBundle().loadClass("com.ibm.ws.jca.internal.BeanValidationHelperImpl").newInstance();
            else
                bvalHelper = AccessController.doPrivileged(new PrivilegedExceptionAction<BeanValidationHelper>() {
                    @Override
                    public BeanValidationHelper run() throws IllegalAccessException, ClassNotFoundException, InstantiationException {
                        return (BeanValidationHelper) componentContext.getBundleContext().getBundle().loadClass("com.ibm.ws.jca.internal.BeanValidationHelperImpl").newInstance();
                    }
                });
            bvalHelper.setBeanValidationSvc(svc);
        }

        resourceAdapter = configureResourceAdapter();
        if (resourceAdapter != null) {
            propagateThreadContext = !"(service.pid=com.ibm.ws.context.manager)".equals(properties.get("contextService.target"));
            workManager = new WorkManagerImpl(this);

            // Normally it's a bad practice to do this in activate. But here we have a requirement to keep the
            // reference count until some subsequent processing occurs after deactivate.
            contextSvc = Utils.priv.getService(componentContext, contextSvcRef);

            jcasu = new JcaServiceUtilities();
            raThreadContextDescriptor = captureRaThreadContext(contextSvc);
            raClassLoader = resourceAdapterSvc.getClassLoader();
            raClassLoader = raClassLoader == null ? null : classLoadingSvc.createThreadContextClassLoader(raClassLoader);

            ArrayList<ThreadContext> threadContext = startTask(raThreadContextDescriptor);
            try {
                beginContext(raMetaData);
                try {
                    ClassLoader previousClassLoader = jcasu.beginContextClassLoader(raClassLoader);
                    try {
                        resourceAdapter.start(this);
                    } finally {
                        jcasu.endContextClassLoader(raClassLoader, previousClassLoader);
                    }
                } finally {
                    endContext(raMetaData);
                }
            } finally {
                stopTask(raThreadContextDescriptor, threadContext);
            }
        }

        latches.put(resourceAdapterID, latch); // only add latch if activate is successful
    }
1346257
@Activated
	public void activated() {
		logger.info("Importing core packages ['org.eiichiro.gig', 'org.eiichiro.bootleg', 'org.eiichiro.jaguar', 'org.eiichiro.jaguar.deployment'] into JavaScript context");
		Context context = factory.enterContext();
		
		try {
			context.evaluateString(scope, "importPackage(Packages.org.eiichiro.gig)", Configuration.class.getSimpleName(), 146, null);
			context.evaluateString(scope, "importPackage(Packages.org.eiichiro.bootleg)", Configuration.class.getSimpleName(), 147, null);
			context.evaluateString(scope, "importPackage(Packages.org.eiichiro.jaguar)", Configuration.class.getSimpleName(), 148, null);
			context.evaluateString(scope, "importPackage(Packages.org.eiichiro.jaguar.deployment)", Configuration.class.getSimpleName(), 149, null);
		} finally {
			Context.exit();
		}
		
		load(COMPONENTS_JS);
		load(ROUTING_JS);
		load(SETTINGS_JS);
	}
902262
protected void activate(ComponentContext context) throws Exception {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Activating");
        }

        processConfig(context.getProperties());

        SystemLogger.setLogService(logService);
    }
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);
				}
			}
		}));
	}
887931
protected void activate(ComponentContext context, Map<String, Object> properties) {
        if (TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, "activate", "context=" + context);
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, "activate", "properties=" + properties);
        }
        embeddableWebSphereTransactionManagerRef.activate(context);
        localTransactionCurrentRef.activate(context);
        resourceConfigFactoryRef.activate(context);
        dataSourceFactoryRef.activate(context);
        uowCurrentRef.activate(context);
        userTransactionRef.activate(context);
        serializationServiceRef.activate(context);
        configurationProperties = properties;

    }
900336
public void activate() {
        // Notify ActivationListeners
    	SipSessionEvent event = null;
    	if(sipSessionAttributeMap != null) {
	        Set<String> keySet = getAttributeMap().keySet();
	        for (String key : keySet) {
	        	Object attribute = getAttributeMap().get(key);
	            if (attribute instanceof SipSessionActivationListener) {
	                if (event == null)
	                	event = new SipSessionActivationEvent(this, SessionActivationNotificationCause.ACTIVATION);
	                try {
	                    ((SipSessionActivationListener)attribute)
	                        .sessionDidActivate(event);
	                } catch (Throwable t) {
	                    logger.error("SipSessionActivationListener threw exception", t);
	                }
	            }
			}
	    }
    }
81807
public static void init(@NonNull Context ctx) {
        if (!INIT_DONE) {
            String[] fonts = GenericsUtil.getDefinedFonts(ctx);
            for (String fontsClassPath : fonts) {
                try {
                    ITypeface typeface = (ITypeface) Class.forName(fontsClassPath).newInstance();
                    validateFont(typeface);
                    FONTS.put(typeface.getMappingPrefix(), typeface);
                } catch (Exception e) {
                    Log.e(TAG, "Can't init: " + fontsClassPath);
                }
            }
            String[] processors = GenericsUtil.getDefinedProcessors(ctx);
            for (String processorClassPath : processors) {
                try {
                    IconicsAnimationProcessor processor = (IconicsAnimationProcessor) Class.forName(processorClassPath).newInstance();
                    registerProcessor(processor);
                } catch (Exception e) {
                    Log.e(TAG, "Can't init: " + processorClassPath);
                }
            }
            INIT_DONE = true;
        }
    }
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");
    }
1113676
protected void activate(ComponentContext context) {
        securityServiceRef.activate(context);
        unauthSubjectServiceRef.activate(context);
        authServiceRef.activate(context);
        credServiceRef.activate(context);
    }
1141862
public void activate() {
        // if no handlers are currently running, start one now
        if (this.numHandlersInFlight.getInt() == 0) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Activating result handler: " + this.completionPort);
            }
            startHandler();
        }
    }
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);
    }
692767
function (cfg, ctxt) {
        // ---------------------------------------------------------------------

        var configurationOfCommonBinding = this._getConfigurationOfCommonBinding(cfg);

        if (configurationOfCommonBinding != null) {
            var bind = cfg.bind;
            var inside = configurationOfCommonBinding.inside;

            bind.controlledTabPanelId = {
                inside: inside,
                to: this._getControlledTabPanelIdPropertyName(cfg)
            };

            bind.labelId = {
                inside: inside,
                to: this._getLabelIdPropertyName(cfg)
            };
        }

        if (cfg.waiAria) {
            this._customTabIndexProvided = true;
        }

        // ---------------------------------------------------------------------

        this.$Container.constructor.apply(this, arguments);
        this._setSkinObj(this._skinnableClass);

        /**
         * Whether the mouse is over the Tab or not
         * @type Boolean
         * @protected
         */
        this._mouseOver = false;

        /**
         * Whether the Tab is focused or not
         * @type Boolean
         * @protected
         */
        this._hasFocus = false;

        this._updateState(true);

        /**
         * Frame instance. Actual instance depends on the skin
         * @type aria.widgets.frames.Frame
         * @protected
         */
        this._frame = ariaWidgetsFramesFrameFactory.createFrame({
            height : cfg.height,
            state : this._state,
            width : cfg.width,
            sclass : cfg.sclass,
            skinnableClass : this._skinnableClass,
            printOptions : cfg.printOptions,
            id : Aria.testMode ? this._domId + "_" + cfg.tabId : undefined
        });

        /**
         * Override default widget's span style
         * @type String
         * @protected
         * @override
         */
        this._spanStyle = "z-index:100;vertical-align:top;";
    }
795277
function (cfg, ctxt) {
        this.$Widget.constructor.apply(this, arguments);

        if (ariaUtilsType.isString(cfg.ellipsis)) {
            this._activateEllipsis = true;
            this._directInit = true;
        }

        this._defaultMargin = 0;
    }
561208
protected void activate(ComponentContext cc) {
        Bundle usingBundle = cc.getUsingBundle();
        userContext = usingBundle.getBundleContext();
    }
270373
@Trivial
    @Activate
    protected void activate(ComponentContext context) {
        Dictionary<String, ?> props = context.getProperties();
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(this, tc, "activate", props);

        String contextSvcName = (String) props.get(JNDI_NAME);
        if (contextSvcName == null)
            contextSvcName = (String) props.get(CONFIG_ID);

        lock.writeLock().lock();
        try {
            componentContext = context;
            properties = props;
            name = contextSvcName;
        } finally {
            lock.writeLock().unlock();
        }

        if (trace && tc.isEntryEnabled())
            Tr.exit(this, tc, "activate");
    }
518605
protected void activate(ComponentContext cc) {
        // Save bundle context for later usage
        BundleContext context = cc.getBundleContext();
        JMXMBeanServerDelegation.INSTANCE.context = context;

        // Create instance of JmxInitializer, set single instance of this class
        // into JmxInitializer as MBeanServer
        LibertyApplicationBusFactory busFactory = LibertyApplicationBusFactory.getInstance();
        jmxInitializer = new JMXBusInitializer(JMXMBeanServerDelegation.getInstance());
        busFactory.registerApplicationBusListener(jmxInitializer);
    }