Starts listening shakes to open LynxActivity if a shake is detected and if the ShakeDetector is
enabled.
487990
public void init(final LynxConfig lynxConfig) {
    ShakeDetector shakeDetector = new ShakeDetector(new ShakeDetector.Listener() {
      @Override public void hearShake() {
        if (isEnabled) {
          openLynxActivity(lynxConfig);
        }
      }
    });
    SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    shakeDetector.start(sensorManager);
  }
1201030
public void startTracking() {
        if (isTracking) {
            return;
        }
        if (this.session == null) {
            addBroadcastReceiver();
        }        
        // if the session is not null, then add the callback to it right away
        if (getSession() != null) {
            getSession().addCallback(callback);
        }
        isTracking = true;
    }
386517
def start(self):
        
        if self._with_discovery:
            # Start the server to listen to new devices
            self.upnp.server.set_spawn(2)
            self.upnp.server.start()
        if self._with_subscribers:
            # Start the server to listen to events
            self.registry.server.set_spawn(2)
            self.registry.server.start()
994472
function start() {
      var _this = this;

      if (Glide.settings.autoplay) {
        if (isUndefined(this._i)) {
          this._i = setInterval(function () {
            _this.stop();

            Components.Run.make('>');

            _this.start();
          }, this.time);
        }
      }
    }
463191
def postActivate_(self):
        
        self.analyzer = LicensePlateDetector(**self.analyzer_pars) # this is called after the fork (i.e. after the multiprocess has been spawned)
        self.report("analyzer object=", self.analyzer)
50052
public void start() {
    syncLock.lock();
    try {
      if (!this.isConfigured) {
        return;
      }
      instanceChangeStreamListener.stop();
      if (listenersEnabled) {
        instanceChangeStreamListener.start();
      }

      if (syncThread == null) {
        syncThread = new Thread(
            new DataSynchronizerRunner(
              new WeakReference<>(this),
              networkMonitor,
              logger
            ),
            "dataSynchronizerRunnerThread"
        );
      }
      if (syncThreadEnabled && !isRunning) {
        syncThread.start();
        isRunning = true;
      }
    } finally {
      syncLock.unlock();
    }
  }
485844
def watchSignal(self, signal):
        
        self._extend_state()

        def signal_handler(*args, **kwargs):
            self._events_seen.append((signal, args, kwargs))
        signal.connect(signal_handler)
        if hasattr(self, 'addCleanup'):
            self.addCleanup(signal.disconnect, signal_handler)
876738
function startListening () {
    if (isBuilt === false) {
      app.listen(
        parseInt(port),
        host,
        () => {
          isBuilt = true
          console.log(chalk.green(`[React Emoji Component SSR] ${host}:${port}`))
        }
      )
    }
  }
1062263
public void triggerSessionCreated(JingleSession jingleSession) {
        jingleSessions.add(jingleSession);
        jingleSession.addListener(this);
        for (CreatedJingleSessionListener createdJingleSessionListener : creationListeners) {
            try {
                createdJingleSessionListener.sessionCreated(jingleSession);
            } catch (Exception e) {
                LOGGER.log(Level.WARNING, "exception", e);
            }
        }
    }
423232
private void notifyStart()
    {
        if (eventHandler instanceof LifecycleAware)
        {
            try
            {
                ((LifecycleAware) eventHandler).onStart();
            }
            catch (final Throwable ex)
            {
                exceptionHandler.handleOnStartException(ex);
            }
        }
    }
1212393
protected void initiateCommsHandshaking() 
      throws SIConnectionLostException, SIConnectionDroppedException
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "initiateCommsHandshaking");
      
      initiateCommsHandshakingImpl(false);
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "initiateCommsHandshaking");
   }
1113204
def activate(self):
        
        response = self._manager.activate(self.ID)
        self._update(response["Bounce"])
        return response["Message"]
825805
protected final void notifyStarted() {
    monitor.enter();
    try {
      // We have to examine the internal state of the snapshot here to properly handle the stop
      // while starting case.
      if (snapshot.state != STARTING) {
        IllegalStateException failure =
            new IllegalStateException(
                "Cannot notifyStarted() when the service is " + snapshot.state);
        notifyFailed(failure);
        throw failure;
      }

      if (snapshot.shutdownWhenStartupFinishes) {
        snapshot = new StateSnapshot(STOPPING);
        // We don't call listeners here because we already did that when we set the
        // shutdownWhenStartupFinishes flag.
        doStop();
      } else {
        snapshot = new StateSnapshot(RUNNING);
        running();
      }
    } finally {
      monitor.leave();
      executeListeners();
    }
  }
706801
public boolean start() {
        if (!this.isStarted.compareAndSet(false, true)) {
            return false;
        }
        final long delay = this.delayBetweenSweeps;
        this.timer.scheduleWithFixedDelay(this, delay, delay, TimeUnit.MILLISECONDS);
        LogWatchStorageSweeper.LOGGER.info(
                "Scheduled automated unreachable message sweep in {} to run every {} millisecond(s).",
                this.messaging.getLogWatch(), delay);
        return true;
    }
1131820
public void trigger(DelegateExecution execution, String signalName, Object signalData) {
    if (activityBehaviorInstance == null) {
      activityBehaviorInstance = getActivityBehaviorInstance();
    }

    if (activityBehaviorInstance instanceof TriggerableActivityBehavior) {
      ((TriggerableActivityBehavior) activityBehaviorInstance).trigger(execution, signalName, signalData);
    } else {
      throw new ActivitiException("signal() can only be called on a " + TriggerableActivityBehavior.class.getName() + " instance");
    }
  }
571262
@Override
	public void messageReceived(IoSession session, Object message)
			throws Exception {
		log.debug("{} <-- {}", session, message);
		if (this.sensorIoAdapter == null) {
			log.warn(
					"No SensorIoAdapter defined. Ignoring message from {}: {}",
					session, message);
			return;
		}

		if (message instanceof SampleMessage) {
			if (this.sensorIoAdapter != null) {
				this.sensorIoAdapter.sensorSampleReceived(session,
						(SampleMessage) message);
			}
		} else if (message instanceof HandshakeMessage) {
			log.debug("Received handshake message from {}: {}", session,
					message);
			if (this.sensorIoAdapter != null) {
				this.sensorIoAdapter.handshakeMessageReceived(session,
						(HandshakeMessage) message);
			}

		} else {
			log.warn("Unhandled message type for session {}: {}", session,
					message);
		}

	}
326236
def start_monitoring(self):
        
        if self.__monitoring is False:
            self.__monitoring = True
            self.__monitoring_action()