Starts this beacon advertising
183713
public void startAdvertising() {
        if (mBeacon == null) {
            throw new NullPointerException("Beacon cannot be null.  Set beacon before starting advertising");
        }
        int manufacturerCode = mBeacon.getManufacturer();
        int serviceUuid = -1;
        if (mBeaconParser.getServiceUuid() != null) {
            serviceUuid = mBeaconParser.getServiceUuid().intValue();
        }

        if (mBeaconParser == null) {
            throw new NullPointerException("You must supply a BeaconParser instance to BeaconTransmitter.");
        }

        byte[] advertisingBytes = mBeaconParser.getBeaconAdvertisementData(mBeacon);
        String byteString = "";
        for (int i= 0; i < advertisingBytes.length; i++) {
            byteString += String.format("%02X", advertisingBytes[i]);
            byteString += " ";
        }
        LogManager.d(TAG, "Starting advertising with ID1: %s ID2: %s ID3: %s and data: %s of size "
                        + "%s", mBeacon.getId1(),
                        mBeacon.getIdentifiers().size() > 1 ? mBeacon.getId2() : "",
                        mBeacon.getIdentifiers().size() > 2 ? mBeacon.getId3() : "", byteString,
                advertisingBytes.length);

        try{
            AdvertiseData.Builder dataBuilder = new AdvertiseData.Builder();
            if (serviceUuid > 0) {
                byte[] serviceUuidBytes = new byte[] {
                        (byte) (serviceUuid & 0xff),
                        (byte) ((serviceUuid >> 8) & 0xff)};
                ParcelUuid parcelUuid = parseUuidFrom(serviceUuidBytes);
                dataBuilder.addServiceData(parcelUuid, advertisingBytes);
                dataBuilder.addServiceUuid(parcelUuid);
                dataBuilder.setIncludeTxPowerLevel(false);
                dataBuilder.setIncludeDeviceName(false);

            } else {
                dataBuilder.addManufacturerData(manufacturerCode, advertisingBytes);
            }

            AdvertiseSettings.Builder settingsBuilder = new AdvertiseSettings.Builder();

            settingsBuilder.setAdvertiseMode(mAdvertiseMode);
            settingsBuilder.setTxPowerLevel(mAdvertiseTxPowerLevel);
            settingsBuilder.setConnectable(mConnectable);

            mBluetoothLeAdvertiser.startAdvertising(settingsBuilder.build(), dataBuilder.build(), getAdvertiseCallback());
            LogManager.d(TAG, "Started advertisement with callback: %s", getAdvertiseCallback());

        } catch (Exception e){
            LogManager.e(e, TAG, "Cannot start advertising due to exception");
        }
    }
207750
public function on_start()
    {
        $this->registerServiceProvider();
        $this->registerParsers();
        $this->app->make('director')->addSubscriber($this->app->make(EventSubscriber::class));
        if ($this->app->isRunThroughCommandLineInterface()) {
            $this->registerCLICommands();
        } else {
            $this->registerAssets();
            $this->registerRoutes();
        }
    }
284840
def start(self):
        
        assert not self._started
        self._listening_stream.on_recv(self._recv_callback)
        self._started = True
1314146
def start(self):
        

        def handle(signum, frame):
            if signum == signal.SIGWINCH:
                self.pty.resize()

        self.original_handler = signal.signal(signal.SIGWINCH, handle)
1365580
def _prompt_started_hook(self):
        """"""
        if not self._reading:
            self._highlighter.highlighting_on = True
            self.sig_prompt_ready.emit()
894352
function start(next) {

        if (!name) {
            throw new Error("Please provide a name for your service if you are using .start(). No spaces.");
        }

        mode = "broadcast";

        log("Starting %s[%s] in %s mode", name, id, mode);
        if (status == "inactive") {
            status = "starting";
            listen(function(err) {
                if (err) {
                    if (typeof next == "function") {
                        next(err);
                    }
                    return;
                }
                log("Listening socket for %s[%s] initiated with port %s", name, id, self.port);
                broadcast(function(err) {
                    status = "broadcasting";
                    log("Broadcast for %s[%s] initiated", name, id);
                    if (typeof next == "function") {
                        next(err);
                    }
                });
            });
        }
        else {
            if (typeof next == "function") {
                next();
            }
        }

    }
476040
def start(self):
        
        self.__stop = False
        self._queue.start()
        self._zk.start()
238720
def start(self):
        """"""
        if self.mode == MODE_PRIMARY:
            i = self._start()
        else:
            i = self._connect()
        self.manager = i
415068
def start(self):
        """"""
        if not self._started:
            self.sig_started.emit(self)
            self._started = True
624268
function _start() {
        if (!$animate) {
          $animate = $injector.get('$animate');
        }

        $timeout.cancel(completeTimeout);

        // do not continually broadcast the started event:
        if (started) {
          return;
        }

        var document = $document[0];
        var parent = document.querySelector ?
          document.querySelector($parentSelector)
          : $document.find($parentSelector)[0]
        ;

        if (! parent) {
          parent = document.getElementsByTagName('body')[0];
        }

        var $parent = angular.element(parent);
        var $after = parent.lastChild && angular.element(parent.lastChild);

        $rootScope.$broadcast('cfpLoadingBar:started');
        started = true;

        if (includeBar) {
          $animate.enter(loadingBarContainer, $parent, $after);
        }

        if (includeSpinner) {
          $animate.enter(spinner, $parent, loadingBarContainer);
        }

        _set(startSize);
      }
267963
public function startAdvertisementChannel($channel, $duration, $cueId, $showSlate)
    {
        $op = $this->sendStartAdvertisementChannelOperation($channel, $duration, $cueId, $showSlate);

        // waiting for create operation finishes
        $op = $this->awaitOperation($op);

        // true if succeeded
        return $op->getState() == OperationState::Succeeded;
    }
1263722
@Override
    protected void onStart() {
        super.onStart();
        mApiClient = new GoogleApiClient.Builder(this)
                .addApi(Wearable.API)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();

        mApiClient.connect();
    }
129345
def set_advertising(self, enabled):
        """"""
        if enabled:
            self.bable.set_advertising(
                enabled=True,
                uuids=[TileBusService.uuid],
                name="V_IOTile ",
                company_id=ArchManuID,
                advertising_data=self._advertisement(),
                scan_response=self._scan_response(),
                sync=True
            )
        else:
            try:
                self.bable.set_advertising(enabled=False, sync=True)
            except bable_interface.BaBLEException:
                # If advertising is already disabled
                pass
1186534
def start (self):
        '''
        

        '''
        self.subrgb = rospy.Subscriber(self.topicrgb, ImageROS)
        self.subd = rospy.Subscriber(self.topicd, ImageROS)
        self.ts = message_filters.ApproximateTimeSynchronizer([subrgb, subd], 1, 0.1, allow_headerless=True)
        self.ts.registerCallback(self.__callback)
211103
def get_beacon():
    ""
    s = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
    s.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, True)
    s.setsockopt(_socket.SOL_SOCKET, _socket.SO_BROADCAST, True)
    return s
346982
def start(self, block=True):
        """"""
        if self._state == INIT:
            if not any(self.on_message.receivers_for(blinker.ANY)):
                raise RuntimeError('no receivers connected to on_message')

            self.logger.debug('starting %s...', self.name)
            self._state = RUNNING
            self.query_nsqd()

            if self.lookupds:
                self.query_lookupd()
                self._killables.add(self._workers.spawn(self._poll_lookupd))

            self._killables.add(self._workers.spawn(self._poll_ready))

        else:
            self.logger.warn('%s already started', self.name)

        if block:
            self.join()
583882
def _start(self):
        """"""
        self._enable_logpersist()
        logcat_file_path = self._configs.output_file_path
        if not logcat_file_path:
            f_name = 'adblog,%s,%s.txt' % (self._ad.model,
                                           self._ad._normalized_serial)
            logcat_file_path = os.path.join(self._ad.log_path, f_name)
        utils.create_dir(os.path.dirname(logcat_file_path))
        cmd = '"%s" -s %s logcat -v threadtime %s >> "%s"' % (
            adb.ADB, self._ad.serial, self._configs.logcat_params,
            logcat_file_path)
        process = utils.start_standing_subprocess(cmd, shell=True)
        self._adb_logcat_process = process
        self.adb_logcat_file_path = logcat_file_path