Start an application with specified profile.

    Does nothing if application is already running.
962259
def app_start(name, profile, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('app:start', **{
        'node': ctx.repo.create_secure_service('node'),
        'name': name,
        'profile': profile
    })
871866
def runprofilerandshow(funcname, profilepath, argv='', *args, **kwargs):
    '''
    
    '''
    functionprofiler.runprofile(funcname+'(\''+argv+'\')', profilepath, *args, **kwargs)
    print 'Showing profile (windows should open in the background)'; sys.stdout.flush();
    functionprofiler.browseprofilegui(profilepath)
175868
def OnInit(self, profile=None, memoryProfile=None):
        """"""
        wx.Image.AddHandler(self.handler)
        frame = MainFrame( config_parser = load_config())
        frame.Show(True)
        self.SetTopWindow(frame)
        if profile:
            wx.CallAfter(frame.load, *[profile])
        elif sys.argv[1:]:
            if sys.argv[1] == '-m':
                if sys.argv[2:]:
                    wx.CallAfter( frame.load_memory, sys.argv[2] )
                else:
                    log.warn( 'No memory file specified' )
            else:
                wx.CallAfter(frame.load, *sys.argv[1:])
        return True
293588
def start_app(app_id, is_finished=False):
    
    state = constant.STATE_APP_RUNNING if is_finished else constant.STATE_APP_STARTING
    app_update_state(app_id, state)
872523
public static void registerHMSPush(Application application, String profile) {
    if (null == application) {
      throw new IllegalArgumentException("[HMS] context cannot be null.");
    }

    if (!isHuaweiPhone()) {
      printErrorLog("[HMS] register error, is not huawei phone!");
      return;
    }

    if (!checkHuaweiManifest(application)) {
      printErrorLog("[HMS] register error, mainifest is incomplete!");
      return;
    }

    hwDeviceProfile = profile;
    boolean hmsInitResult = com.huawei.android.hms.agent.HMSAgent.init(application);
    if (!hmsInitResult) {
      LOGGER.e("failed to init HMSAgent.");
    }

    LOGGER.d("[HMS] start register HMS push");
  }
86878
static public function start( $name )
    {
        if ( !ObjectManager::getInstance()->get( Config::class )->getValue( 'profile' ) ) {
            return;
        }

        if ( !isset( self::$profileNames[$name] ) ) {
            self::$profileNames[$name] = 0;
        }
        $realName = $name . '_' . self::$profileNames[$name] ++;
        array_push( self::$currentProfileNames, $realName );

        self::$profiles[implode( self::PATH_SEPARATOR, self::$currentProfileNames )] = [
            'start_at' => microtime( true ),
            'start_used_memory' => memory_get_usage()
        ];
    }
616488
public void init(ServletContext context) {
        if (profiles != null) {
            for (IDiagramProfile profile : profiles) {
                profile.init(context);
                _registry.put(profile.getName(),
                              profile);
            }
        }
    }
705483
def run(self):
        
        LOGGER.info('%s v%s started', self.APPNAME, self.VERSION)
        self.setup()
        while not any([self.is_stopping, self.is_stopped]):
            self.set_state(self.STATE_SLEEPING)
            try:
                signum = self.pending_signals.get(True, self.wake_interval)
            except queue.Empty:
                pass
            else:
                self.process_signal(signum)
                if any([self.is_stopping, self.is_stopped]):
                    break
            self.set_state(self.STATE_ACTIVE)
            self.process()
1365378
def setAsApplication(myappid):
    

    if os.name == 'nt':
        import ctypes
        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
361110
def run(**kwargs):
    
    from sampleproject.app import app

    app.update_settings(**kwargs)
    app.run()
1244833
def run():
    
    options = btoptions.Options()
    btlog.initialize_logging(options.log_level, options.log_file)
    app = btapp.get_application()
    app.run()
1374324
def app_run(app_name_or_id, alias=None, input_params={}, always_retry=True, **kwargs):
    
    input_params_cp = Nonce.update_nonce(input_params)
    fully_qualified_version = app_name_or_id + (('/' + alias) if alias else '')
    return DXHTTPRequest('/%s/run' % fully_qualified_version, input_params_cp, always_retry=always_retry, **kwargs)
1338820
def start_app(self, app_id, force_launch=False):
        
        self.logger.info("Starting app %s", app_id)

        self.socket_client.receiver_controller.launch_app(app_id, force_launch)
3912
def activate(self, profile_name=NotSet):
        
        if profile_name is NotSet:
            profile_name = self.profile_name
        self._active_profile_name = profile_name
127407
def hasApplication(self, app):
        
        if self._applications is None:
            self._initApplicationList()
        return app in self._applications
505484
def start(self):
        
        self.recieve('APP_START')
        self.alive = True
        while self.alive:
            message, payload = self.messages.get()
            if message == 'APP_STOP':
                for plugin in self.plugins:
                    plugin.recieve('SHUTDOWN')
                self.alive = False
            else:
                self.recieve(message, payload)
1297877
def start_app(self, bundle_id):
        '''
        
        '''
        idevicedebug = must_look_exec('idevicedebug')

        # run in background
        kwargs = {'stdout': subprocess.PIPE, 'stderr': subprocess.PIPE}
        if sys.platform != 'darwin':
            kwargs['close_fds'] = True
        return subprocess.Popen([idevicedebug, "--udid", self.udid, 'run', bundle_id], **kwargs)