Полноэкранный режим в гибком мобильном проекте

у меня есть необходимость стадии видео, чтобы добавить полную кнопку экрана, я добавил этот код:Полноэкранный режим в гибком мобильном проекте

private function makeFullScreenVideo(e:Event):void 
    { 
     saveOldestPositionAndSizeOfVideo(); 
     if(!isFull) 
     { 
      stage.getChildAt(0).x = 0; 
      stage.getChildAt(0).y = 0; 
      stage.getChildAt(0).width = stage.fullScreenWidth; 
      stage.getChildAt(0).height = stage.fullScreenHeight; 

     } 
     else 
     { 
      if(stage.fullScreenHeight>stage.fullScreenWidth) 
      { 
       stage.getChildAt(0).x = oldXOfVerticalView; 
       stage.getChildAt(0).y = oldYOfVerticalView; 
       stage.getChildAt(0).width = oldWidthOfVerticalView; 
       stage.getChildAt(0).height = oldHeightOfVerticalView; 
      } 
      else 
      { 
       stage.getChildAt(0).x = oldXOfHorizentalView; 
       stage.getChildAt(0).y = oldYOfHorizentalView; 
       stage.getChildAt(0).width = oldWidthOfHorizentalView; 
       stage.getChildAt(0).height = oldHeightOfHorizentalView; 
      } 
     } 

     isFull = !isFull; 

    } 
    private function saveOldestPositionAndSizeOfVideo():void 
    { 
     if(stage.fullScreenHeight>stage.fullScreenWidth) 
     { 
      oldWidthOfVerticalView = stage.fullScreenWidth; 
      oldHeightOfVerticalView= stage.fullScreenHeight*0.468; 
      oldXOfVerticalView= 0; 
      oldYOfVerticalView= 0; 
     } 
     else 
     { 
      if(oldWidthOfHorizentalView == 0) 
      { 
       oldWidthOfHorizentalView = stage.getChildAt(0).width; 
       oldHeightOfHorizentalView= stage.getChildAt(0).height; 
       oldXOfHorizentalView= stage.getChildAt(0).x; 
       oldYOfHorizentalView= stage.getChildAt(0).y;  
      } 
     } 
    }

этот код работает хорошо, когда я запустить его. проблема, когда ориентация изменяется, если изменить ориентацию в полноэкранном режиме не будет делать для кода я пишу его в StageOrientationEvent:

private function changeOrientation(evt:StageOrientationEvent):void 
    { 
     if(isFull) 
     { 
      stage.getChildAt(0).x = 0; 
      stage.getChildAt(0).y = 0; 
      stage.getChildAt(0).width = stage.fullScreenWidth; 
      stage.getChildAt(0).height = stage.fullScreenHeight; 
     } 
    }

Подсказка: если я запустить проект на рабочем столе не на Разрабатывают его будет отлично работать, и нет никакой ориентации на ориентацию.

источник

2013-04-22 Sameer H. Ibra

Hi Sameer Я также сталкиваюсь с проблемами с StageOrientationEvent в мобильном проекте, что несколько похоже на проблему, за исключением того, что он просто не срабатывает при возврате к ориентации по умолчанию. В итоге я просто полагался на класс Accelerometer, чтобы сам определить ориентацию, если вы хотите, чтобы я мог опубликовать этот код. – shaunhusain

@shaunhusain: да, мне бы это понравилось, спасибо –

Вот код, который я собрал для своего проекта после того, как у меня возникли трудности со встроенным элементом StageOrientationEvents. Обратите внимание, что это WIP, поэтому, если у вас есть предложения, сообщите мне. Там в два класса, которые я сделал один Singleton и один событие отправляется, чтобы использовать его я получаю экземпляр одноточечного и добавить слушателей для событий:

[AccelerometerManager.as]

package com.shaunhusain.fingerPainting.managers 
{ 
    import com.shaunhusain.fingerPainting.events.AccBasedOrientationEvent; 

    import flash.events.AccelerometerEvent; 
    import flash.events.EventDispatcher; 
    import flash.sensors.Accelerometer; 

    /** 
    * Centralizes the handling of accelerometer changes, limits events 
    * dispatched to avoid extraneous jiggle/dithering. 
    */ 
    public class AccelerometerManager extends EventDispatcher 
    { 
     //-------------------------------------------------------------------------------- 
     //    Constants 
     //-------------------------------------------------------------------------------- 
     public static const LANDSCAPE_LEFT:String = "landscapeLeft"; 
     public static const LANDSCAPE_RIGHT:String = "landscapeRight"; 
     public static const PORTRAIT_DEFAULT:String = "portraitDefault"; 
     public static const PORTRAIT_FLIPPED:String = "portraitFlipped"; 

     public static const TURNED_RIGHT:String = "turnedRight"; 
     public static const TURNED_LEFT:String = "turnedLeft"; 
     public static const FLIPPED:String = "flipped"; 

     //-------------------------------------------------------------------------------- 
     //    Variables 
     //-------------------------------------------------------------------------------- 
     private var acc:Accelerometer; 
     private var registeredStageListener:Boolean; 
     private var previousOrientation:String=PORTRAIT_DEFAULT; 
     private var degreeAllowance:Number = 20; 
     private var previousAngle:Number=270; 

     //-------------------------------------------------------------------------------- 
     //    Constructor 
     //-------------------------------------------------------------------------------- 
     /** 
     * Used to coordinate all the updates to the buttons without having 
     * multiple instances of accelerometer objects. Creates the handle 
     * to the Accelerometer. 
     * 
     * @param se Blocks creation of new managers instead use static method getInstance 
     */ 
     public function AccelerometerManager(se:SingletonEnforcer) 
     { 
      acc = new Accelerometer(); 
     } 

     //-------------------------------------------------------------------------------- 
     //    Singleton 
     //-------------------------------------------------------------------------------- 
     private static var instance:AccelerometerManager; 
     public static function getIntance():AccelerometerManager 
     { 
      if(instance == null) instance = new AccelerometerManager(new SingletonEnforcer()); 
      return instance; 
     } 

     //-------------------------------------------------------------------------------- 
     //    Properties 
     //-------------------------------------------------------------------------------- 

     private var _currentlyActive:Boolean; 
     /** 
     * Allows the manager to be turned on or off from the outside. 
     */ 
     public function set currentlyActive(value:Boolean):void{ 
      if(_currentlyActive == value) 
       return; 
      _currentlyActive = value; 
      if(_currentlyActive) 
       acc.addEventListener(AccelerometerEvent.UPDATE, handleAccelerometerChange); 
      else 
       acc.removeEventListener(AccelerometerEvent.UPDATE, handleAccelerometerChange); 
     } 

     private var _currentOrientation:String = AccelerometerManager.PORTRAIT_DEFAULT; 
     public function get currentOrientation():String 
     { 
      return _currentOrientation; 
     } 

     public function set currentOrientation(value:String):void 
     { 
      _currentOrientation = value; 
     } 


     //-------------------------------------------------------------------------------- 
     //    Handlers 
     //-------------------------------------------------------------------------------- 
     private function handleAccelerometerChange(event:AccelerometerEvent):void 
     { 
      if(Math.abs(event.accelerationZ)<.75) 
      { 
       var angle:Number = Math.atan2(event.accelerationY, event.accelerationX); 
       var degrees:Number = angle*180/Math.PI+180; 

       if(Math.abs(degrees - previousAngle)<degreeAllowance) 
        return; 

       previousAngle = degrees; 

       var accEventExtra:AccBasedOrientationEvent = new AccBasedOrientationEvent(event.type,event.bubbles,event.cancelable); 
       if(degrees>225&&degrees<315) 
        currentOrientation = PORTRAIT_DEFAULT; 
       else if(degrees>45&&degrees<135) 
        currentOrientation = PORTRAIT_FLIPPED; 
       else if(degrees>=135&&degrees<=225) 
        currentOrientation = LANDSCAPE_LEFT; 
       else if(degrees>=315||degrees<=45) 
        currentOrientation = LANDSCAPE_RIGHT; 

       if(currentOrientation == previousOrientation) 
        return; 

       accEventExtra.oldOrientation = previousOrientation; 
       accEventExtra.newOrientation = currentOrientation; 
       accEventExtra.directionOfChange = determineDirectionOfChange(previousOrientation,currentOrientation); 

       previousOrientation = currentOrientation; 

       dispatchEvent(accEventExtra); 
      } 
     } 
     private function determineDirectionOfChange(oldOrientation:String, newOrientation:String):String 
     { 
      var turned:String; 
      switch(oldOrientation) 
      { 
       case PORTRAIT_DEFAULT: 
        switch(newOrientation) 
        { 
         case LANDSCAPE_LEFT: 
          turned = TURNED_LEFT; 
          break; 
         case LANDSCAPE_RIGHT: 
          turned = TURNED_RIGHT; 
          break; 
         case PORTRAIT_FLIPPED: 
          turned = FLIPPED; 
          break; 
        } 
       break; 
       case LANDSCAPE_LEFT: 
        switch(newOrientation) 
        { 
         case PORTRAIT_DEFAULT: 
          turned = TURNED_RIGHT; 
          break; 
         case LANDSCAPE_RIGHT: 
          turned = FLIPPED; 
          break; 
         case PORTRAIT_FLIPPED: 
          turned = TURNED_LEFT; 
          break; 
        } 
        break; 
       case LANDSCAPE_RIGHT: 
        switch(newOrientation) 
        { 
         case LANDSCAPE_LEFT: 
          turned = FLIPPED; 
          break; 
         case PORTRAIT_DEFAULT: 
          turned = TURNED_LEFT; 
          break; 
         case PORTRAIT_FLIPPED: 
          turned = TURNED_RIGHT; 
          break; 
        } 
        break; 
       case PORTRAIT_FLIPPED: 
        switch(newOrientation) 
        { 
         case LANDSCAPE_LEFT: 
          turned = TURNED_RIGHT; 
          break; 
         case LANDSCAPE_RIGHT: 
          turned = TURNED_LEFT; 
          break; 
         case PORTRAIT_DEFAULT: 
          turned = FLIPPED; 
          break; 
        } 
        break; 

      } 
      return turned; 
     } 
    } 
} 

internal class SingletonEnforcer {public function SingletonEnforcer(){}}

[AccBasedOrientationEvent.as ]

package com.shaunhusain.fingerPainting.events 
{ 
    import flash.events.Event; 

    /** 
    * Added a property to store the current linearRotation pre-computed so 
    * each handler doesn't have to compute it. 
    */ 
    public class AccBasedOrientationEvent extends Event 
    { 
     public var oldOrientation:String; 
     public var newOrientation:String; 
     public var directionOfChange:String; 
     public function AccBasedOrientationEvent(type:String, bubbles:Boolean=false, cancelable:Boolean=false, oldOrientation:String=null, newOrientation:String=null, directionOfChange:String=null) 
     { 
      super(type, bubbles, cancelable); 
      this.oldOrientation = oldOrientation; 
      this.newOrientation = newOrientation; 
      this.directionOfChange = directionOfChange; 
     } 
    } 
}

Использование должен закончить тем, что-то вроде этого:

    { 
        ... 
        var accManager:AccelerometerManager = AccelerometerManager.getIntance(); 
       accManager.addEventListener(AccelerometerEvent.UPDATE, handleAccelerometerChange); 

       var locRot:Number; 
       switch(accManager.currentOrientation) 
       { 
        case AccelerometerManager.PORTRAIT_DEFAULT: 
         locRot = 0; 
         break; 
        case AccelerometerManager.PORTRAIT_FLIPPED: 
         locRot = Math.PI; 
         break; 
        case AccelerometerManager.LANDSCAPE_LEFT: 
         locRot = Math.PI/2; 
         break; 
        case AccelerometerManager.LANDSCAPE_RIGHT: 
         locRot = -Math.PI/2; 
         break; 
       } 

       var ge:GenericActuator = Actuate.tween(this, 1, {rotateAroundCenter:locRot}); 
          ... 
         } 

private function handleAccelerometerChange(event:AccBasedOrientationEvent):void 
     { 
      var locRot:Number; 
      switch(event.newOrientation) 
      { 
       case AccelerometerManager.PORTRAIT_DEFAULT: 
        locRot = 0; 
        break; 
       case AccelerometerManager.PORTRAIT_FLIPPED: 
        locRot = Math.PI; 
        break; 
       case AccelerometerManager.LANDSCAPE_LEFT: 
        locRot = Math.PI/2; 
        break; 
       case AccelerometerManager.LANDSCAPE_RIGHT: 
        locRot = -Math.PI/2; 
        break; 
      } 

      var ge:GenericActuator = Actuate.tween(this, 1, {rotateAroundCenter:locRot}); 
      //rotateAroundCenter = event.linearRotation; 
     }

Примечание. Я использую библиотеку Actuate в примере для анимации поворотов, это совсем не обязательно, все остальное здесь должно быть встроено или приведено выше.

источник

2013-04-22 11:09:14 shaunhusain

хорошая идея, что вы делаете с помощью Accelerometer, я попробовал некоторое решение для своего кода, и это сработало, а не профессиональный код, но теперь он делает работу, просто решение добавляет таймер in: private function changeOrientation (evt: StageOrientationEvent): void, на одну секунду после этого установите ширину и другое свойство, я попробую ваш код, спасибо за блестящую идею. –

спасибо, yah звучит так, как будто ваша проблема должна быть связана как-то с временем отправки события против времени, когда эти свойства для fullScreenWidth и height обновляются (возможно, вы могли бы прослушивать событие изменения размера). Дайте мне знать, если вы закончите использовать это и столкнетесь с какими-либо трудностями до сих пор, он был разработан без проблем для меня. – shaunhusain

Полноэкранный режим в гибком мобильном проекте

ответ

Смежные вопросы