WS-Blog » Debugging http://www.websector.de/blog // Flex - AIR - Flash - JavaScript Wed, 18 Jan 2012 12:17:16 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 WSPluginSwitcher: Cocoa based tool for switching Flash plug-in on OS X http://www.websector.de/blog/2009/01/02/wspluginswitcher-cocoa-based-tool-for-switching-flash-plug-in-on-os-x/ http://www.websector.de/blog/2009/01/02/wspluginswitcher-cocoa-based-tool-for-switching-flash-plug-in-on-os-x/#comments Fri, 02 Jan 2009 15:54:12 +0000 sectore http://www.websector.de/blog/?p=104

It’s never to late to learn a new (programming) language ;) So I’ve been starting to learn Cocoa, Apple’s Objective-C based programming environment for Mac OS X.

My “Cocoa”-trip started with building a little application called “WSPluginSwitcher“, which is a Cocoa based tool for switching Flash plug-ins on OS X (Leopard).

Check it out – it’s open source, including its source code: WSPluginSwitcher on Google Code

Screen shots

Download WSPluginSwitcher including full source

You can download WSPluginSwitcher at its Google Code project.

To get the full source checkout the latest code using WSPluginSwitchers repository at Google Code.

It’s open source!

BTW: I’m very new to Cocoa, so I’m very happy about any feedback ;)

Helpful links for learning Cocoa as an ActionScript Developer

About 10 days of programming a new language is not enough to make a real statement… However, what I’ve have learned so far is: To learn Cocoa as quick as possible you will need a good book! Apple delivers tons of Cocoa guides, but it takes me (too) much time to find basic solutions. I know why I love Adobes Flex and AIR docs ;)

So I highly recommend the book called “Cocoa Programming for Max OS X” by Aaron Hillegass, which helps me a lot!

Further helpful links (not only for ActionScript Developers) are:

P.S.: Happy Flash plug-in switching using WSPluginSwitcher! ;)

]]> http://www.websector.de/blog/2009/01/02/wspluginswitcher-cocoa-based-tool-for-switching-flash-plug-in-on-os-x/feed/ 9 The new ThunderBolt AS3 Console based on Adobe AIR http://www.websector.de/blog/2008/06/01/the-new-thunderbolt-as3-console-based-on-adobe-air/ http://www.websector.de/blog/2008/06/01/the-new-thunderbolt-as3-console-based-on-adobe-air/#comments Sun, 01 Jun 2008 17:23:00 +0000 sectore http://www.websector.de/blog/2008/06/01/the-new-thunderbolt-as3-console-based-on-adobe-air/ [...]]]> ThunderBolt AS3 is a lightweight logger extension for Flex or Flash application using Firebug. With its new tool called ThunderBolt AS3 Console, which based on Adobe AIR, it’s independent on Firebug. That’s incredible helpful for logging AIR applications using ThunderBolt AS3.

Screen shots

[kml_flashembed publishmethod="dynamic" fversion="9.0.28" movie="http://www.websector.de/blog/wp-includes/swf/ws-slideshow.swf" width="500" height="400" targetclass="flashmovie" menu="false" bgcolor="#FFFFFF" allowfullscreen="true" allowscriptaccess="sameDomain" fvars="XMLPath=http://www.websector.de/blog/wp-content/uploads/2008/06/01/screenshots.xml;langID=EN"]

Behind the scenes

For logging without Firebug, ThunderBolt AS3 uses the well-known trace() method in a special manner, which are stored in the flashlog.txt. ThunderBolt AS3 Console reads this file and displays all information using different log views in a same way as Firebug it does.

The architecture behind this AIR application based on Tom Bray’s easyMVC concept, which helps to build a well structured application as quick as possible using the MVC pattern.

ThunderBolt AS3 Console uses the following libraries as well:

Full source available

Download the ThunderBolt AS3 Console at Google Code or check out the full source using its repository.

Wiki pages at Google Code

Happy logging! ;-)

]]> http://www.websector.de/blog/2008/06/01/the-new-thunderbolt-as3-console-based-on-adobe-air/feed/ 18 AsUnit (AS3): RemoteTestCase for testing asynchronous data using Flash Remoting http://www.websector.de/blog/2007/11/29/asunit-as3-remotetestcase-for-testing-asynchronous-data-using-flash-remoting/ http://www.websector.de/blog/2007/11/29/asunit-as3-remotetestcase-for-testing-asynchronous-data-using-flash-remoting/#comments Thu, 29 Nov 2007 13:09:00 +0000 sectore http://www.websector.de/blog/2007/11/29/asunit-as3-remotetestcase-for-testing-asynchronous-data-using-flash-remoting/ UPDATE 12/05/07: Luke Bayes has added the RemotingTestCase to AsUnits repository. Thanks Luke!

AsUnit is the first choice for Test-Driven Development using pure Flash applications. However, currently you find only one test case for asynchronous data using an instance of the flash.net.URLLoader class, but it seems neither for calling methods based on Flash Remoting using the flash.net.NetConnection class. So I decided to add a new test case called asunit.framework.RemotingTestCase” to the AsUnit Framework and hope it would be helpful for the community – check it out ;-)

Examples

Successfully asynchronous tests

Unsuccessfully asynchronous tests


Source

For more information check out the comments within the code, too ;-)

asunit.framework.RemotingTestCase ( Download code )

  1. package asunit.framework
  2. {
  3.     import flash.errors.IllegalOperationError;
  4.     import flash.events.IOErrorEvent;
  5.     import flash.events.NetStatusEvent;
  6.     import flash.events.SecurityErrorEvent;
  7.     import flash.net.NetConnection;
  8.     import flash.net.ObjectEncoding;
  9.     import flash.net.Responder;
  10.    
  11.     import asunit.framework.TestCase;
  12.     import asunit.util.ArrayIterator;   
  13.  
  14.     /**
  15.      * RemotingTestCase
  16.      * @author  Jens Krause [www.websector.de]
  17.      * @date    11/29/07
  18.      *
  19.      */
  20.     public class RemotingTestCase extends TestCase
  21.     {
  22.  
  23.         protected var connection: NetConnection;
  24.         /**
  25.         * Constructor
  26.         * @param testMethod  String      Name of the test case
  27.         *
  28.         */     
  29.         public function RemotingTestCase(testMethod: String = null)
  30.         {
  31.             super(testMethod);
  32.         }
  33.  
  34.         /**
  35.         * Inits a netConnection instance and add all necessary event listeners
  36.         *
  37.         */ 
  38.         protected function initConnection():void
  39.         {
  40.             if (connection == null)
  41.             {
  42.                 connection = new NetConnection();
  43.                
  44.                 connection.addEventListener(NetStatusEvent.NET_STATUS, connectionStatusHandler);
  45.                 connection.addEventListener(IOErrorEvent.IO_ERROR, connectionIOErrorHandler);
  46.                 connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR , connectionSecurityErrorHandler);       
  47.             }
  48.         }
  49.  
  50.         /**
  51.         * Dispose the netConnection instance
  52.         *
  53.         */         
  54.         protected function disposeConnection():void
  55.         {
  56.             if (connection != null)
  57.             {
  58.                 connection.removeEventListener(NetStatusEvent.NET_STATUS, connectionStatusHandler);
  59.                 connection.removeEventListener(IOErrorEvent.IO_ERROR, connectionIOErrorHandler);
  60.                 connection.removeEventListener(SecurityErrorEvent.SECURITY_ERROR , connectionSecurityErrorHandler); 
  61.                
  62.                 connection = null;     
  63.             }
  64.         }
  65.  
  66.         /**
  67.         * Callback handler for receiving SecurityErrorEvent
  68.         * @param event    SecurityErrorEvent
  69.         *
  70.         */ 
  71.         protected function connectionSecurityErrorHandler(event: SecurityErrorEvent): void
  72.         {
  73.             result.addError(this, new IllegalOperationError(event.toString()));
  74.             isComplete = true; 
  75.         }
  76.  
  77.         /**
  78.         * Callback handler for receiving IOErrorEvent
  79.         * @param event    IOErrorEvent
  80.         *
  81.         */ 
  82.         protected function connectionIOErrorHandler(event: IOErrorEvent): void
  83.         {
  84.             result.addError(this, new IllegalOperationError(event.toString()));
  85.             isComplete = true;
  86.         }
  87.  
  88.         /**
  89.         * Callback handler for receiving NetStatusEvent
  90.         * @param event    NetStatusEvent
  91.         *
  92.         */
  93.         protected function connectionStatusHandler(event: NetStatusEvent): void
  94.         {
  95.            
  96.         }
  97.  
  98.         /**
  99.         * Connects the gateway
  100.         *
  101.         * @param $gateway      String  Remote gateway
  102.         * @param $encoding    uint    Object encoding using either AMF0 or AMF3
  103.         *
  104.         */                 
  105.         protected function connect ($gateway: String = null, $encoding: uint = 0): void
  106.         {
  107.             initConnection();
  108.            
  109.          connection.objectEncoding = ($encoding > ObjectEncoding.AMF0) ? $encoding : ObjectEncoding.AMF0;
  110.                
  111.          try {
  112.           connection.connect($gateway);
  113.          }
  114.          catch(error: Error)
  115.          {
  116.              result.addError(this, error);                   
  117.          }
  118.         };
  119.    
  120.         /**
  121.         * Calls a remote service method and test it
  122.         *
  123.         * @param $method        String    Remote service
  124.         * @param $responder  Responder    Responder to handle remoting calls
  125.         * @param $arguments  Array        Rest paramaters (optional)
  126.         *
  127.         */ 
  128.         protected function call ($method: String = null, $responder: Responder = null, …$arguments): void 
  129.         {
  130.             var hasReferenceError: Boolean = false;
  131.            
  132.             // parameters for calling connection.call();
  133.             // To avoid using the type unsafe …rest operator I decided to use type safe parameters within RemotingTestCase.call()
  134.             // and apply these later to connection.call();
  135.             var params: Array = [];
  136.            
  137.             // check remote method
  138.             if ($method != null)
  139.             {
  140.                 params.push($method);         
  141.             }
  142.             else
  143.             {
  144.                 result.addError(this, new ReferenceError("RemotingTestCase.call() has to defined a remote method."));         
  145.                 hasReferenceError = true;
  146.             }
  147.            
  148.             // check responder
  149.             if ($responder != null)
  150.             {
  151.                 params.push($responder);           
  152.             }
  153.             else
  154.             {
  155.                 result.addError(this, new ReferenceError("RemotingTestCase.call() has to defined a responder to handling its results."));            
  156.                 hasReferenceError = true;         
  157.             }   
  158.            
  159.             // In case of a reference error invoke test running instantly
  160.             // to show the errors created above and return
  161.             if (hasReferenceError)
  162.             {
  163.                 super.run();
  164.                 return;
  165.             }
  166.            
  167.            
  168.             var arrIterator: ArrayIterator = new ArrayIterator($arguments);
  169.             while (arrIterator.hasNext())
  170.             {
  171.                 params.push(arrIterator.next());   
  172.             }   
  173.            
  174.             // call remote service
  175.          try {
  176.                 connection.call.apply(null, params);               
  177.          }
  178.          catch(error: Error)
  179.          {
  180.              result.addError(this, error);                    
  181.          }
  182.             
  183.  
  184.         };   
  185.     }
  186. }
  187.  

The following test example based on my Flash Remoting example using OpenAMF described at the previous article called “Best practices: Custom class mapping using OpenAMF and AS3 (Flash CS3 – not Flex)”

RemotingTestCaseExample.as ( Download code )

  1. package tests
  2. {
  3.     import flash.net.ObjectEncoding;
  4.     import flash.net.Responder;
  5.    
  6.     import asunit.framework.RemotingTestCase;   
  7.  
  8.     /**
  9.      * RemotingTestCaseExample
  10.      * @author  Jens Krause [www.websector.de]
  11.      * @date    11/29/97
  12.      */
  13.     public class RemotingTestCaseExample extends RemotingTestCase
  14.     {      
  15.         private var _result: Object;
  16.         private var _userVO: UserVO;
  17.        
  18.         /**
  19.         * Constructor
  20.         * @param testMethod  String      Name of the test case
  21.         *
  22.         */ 
  23.         public function RemotingTestCaseExample(testMethod: String = null)
  24.         {
  25.             super(testMethod);
  26.            
  27.         }
  28.  
  29.         /**
  30.         * After a test is executed the tearDown method is called
  31.         * and removed all references to test objects
  32.         *
  33.         */     
  34.         override protected function tearDown():void
  35.         {         
  36.             _userVO = null;
  37.         }
  38.  
  39.         /**
  40.         * Before a test is executed the setUp method is called
  41.         * which instantiate all necessary test objects
  42.         *
  43.         */ 
  44.  
  45.          override protected function setUp(): void
  46.          {
  47.             _userVO = _result as UserVO;
  48.          }
  49.  
  50.         /**
  51.         * Runs the test
  52.         *
  53.         */     
  54.         public override function run():void
  55.         {
  56.             UserVO.register();
  57.            
  58.             _result = new Object(); 
  59.                    
  60.             var gateway: String = "http://localhost:8080/mappingExample/gateway";
  61.             var encoding: uint = ObjectEncoding.AMF0;
  62.            
  63.             var method: String = "de.websector.blog.openamf.mapping.services.UserServices.getUserByName";
  64.             var responder:Responder = new Responder(onResult, onFault);
  65.            
  66.             super.connect(gateway, encoding);
  67.            
  68.             super.call(method, responder, "Luke Skywalker");   
  69.  
  70.         }
  71.        
  72.         /**
  73.         * Callback handler for receiving a fault
  74.         * @param $result        Object
  75.         *
  76.         */ 
  77.         private function onFault($result: Object):void
  78.         {
  79.             result.addError(this, new Error($result.toString()));
  80.             // call super.run() to execute test methods
  81.             super.run();
  82.         }
  83.        
  84.         /**
  85.         * Callback handler for receiving a result
  86.         * @param $result        Object
  87.         *
  88.         */   
  89.         private function onResult($result: Object):void
  90.         {
  91.             _result = $result;
  92.  
  93.             super.disposeConnection();   
  94.             // call super.run() to execute test methods
  95.             super.run();
  96.         }
  97.        
  98.         /**
  99.         * Tests the userVO
  100.         */
  101.         public function testUserVO():void
  102.         {
  103.             assertTrue("result is instance of ", _result is UserVO);   
  104.         }
  105.        
  106.         /**
  107.         * Tests the userName
  108.         */
  109.         public function testUserName():void
  110.         {   
  111.             assertEquals("UserName Luke Skywalker", _userVO.userName, "Luke Skywalker");               
  112.         }   
  113.  
  114.         /**
  115.         * Tests the registerDate
  116.         */
  117.         public function testRegisterDate():void
  118.         {   
  119.             assertTrue("Register date ", _userVO.registerDate is Date); 
  120.         }   
  121. //   
  122. //    /**
  123. //     * Test that is born to lose.
  124. //     */
  125. //    public function testFail():void
  126. //    {
  127. //     assertFalse("failing test", true);
  128. //    }
  129.                
  130.     }
  131. }
  132.  

Download

Source including test example files:
RemotingTestCaseExample.zip (Downloads: 937)

Happy (asynchronous) testing! ;-)

Acknowledge

]]> http://www.websector.de/blog/2007/11/29/asunit-as3-remotetestcase-for-testing-asynchronous-data-using-flash-remoting/feed/ 3 ThunderBolt AS3 1.0 released – A lightweight logging tool for Flex 2 and Flash CS3 applications http://www.websector.de/blog/2007/10/14/thunderbolt-as3-10-released-a-lightweight-logging-tool-for-flex-2-and-flash-cs3-applications/ http://www.websector.de/blog/2007/10/14/thunderbolt-as3-10-released-a-lightweight-logging-tool-for-flex-2-and-flash-cs3-applications/#comments Sun, 14 Oct 2007 09:51:00 +0000 sectore http://www.websector.de/blog/2007/10/14/thunderbolt-as3-10-released-a-lightweight-logging-tool-for-flex-2-and-flash-cs3-applications/ ThunderBolt AS3 is a lightweight logging tool for Flex 2 and Flash CS3 applications using Firebug as its logging console. It’s open source based on the Mozilla Public License 1.1.

Features based on ThunderBolt AS3 v.1.0

  • Log levels: INFO, WARN, ERROR, DEBUG (FATAL, ALL)
  • Tree view for complex object structures such as class identifier and its properties
  • Custom LogTarget based on Flex Logging API including filters
  • Memory snapshot
  • SWC components for logging using Flex 2 or Flash CS3. Only 4kB for the Flash based SWC and 24kB for Flex one using the Flex 2 Logging Framework.

For more information check the Wiki on Google Code.

Live examples

Note: Press F12 to open Firebug within Firefox to receive all logging messages.
Any questions…? What the fuck is Firebug…? ;-)

Pure Flex 2 example:

Get Adobe Flash player

 

Flex 2 example using the Flex 2 Logging Framework:

Get Adobe Flash player

 

Pure Flash CS3 example:

Get Adobe Flash player

 

Free download

Full source of ThunderBolt AS3 including all examples and libraries as SWC’s:
ThunderBoltAS3_v1.0.zip
(Downloads: 1804)

Happy logging ;-) !

]]> http://www.websector.de/blog/2007/10/14/thunderbolt-as3-10-released-a-lightweight-logging-tool-for-flex-2-and-flash-cs3-applications/feed/ 25 Detecting memory leaks in Flash or Flex applications using WSMonitor http://www.websector.de/blog/2007/10/01/detecting-memory-leaks-in-flash-or-flex-applications-using-wsmonitor/ http://www.websector.de/blog/2007/10/01/detecting-memory-leaks-in-flash-or-flex-applications-using-wsmonitor/#comments Mon, 01 Oct 2007 09:23:00 +0000 sectore http://www.websector.de/blog/2007/10/01/detecting-memory-leaks-in-flash-or-flex-applications-using-wsmonitor/ ]]> WSMonitor is a handy tool based on AS3 to detect memory issues in Flash or Flex applications. It’s simple to use and it’s free – including full source.

Example

Press start button to run WSMonitor. All Flash movies running within this Browser are monitored, such as the maps.amung.us plugin located on right hand.

[kml_flashembed movie="http://www.websector.de/blog/wp-content/uploads/2007/10/01/WSMonitor.swf" width="330" height="220" bgcolor="#FFFFFF" fversion="9.0.28" menu="false"]

Get Adobe Flash player

 

Instruction

Just open your Flash or Flex app within Browser or Flash Standalone Player and start WSMonitor using WSMonitor.html or WSMonitor.swf located in folder named “deploy”.

Note: WSMonitor and your app have to run with the same Flash Player.

Free download

WSMonitor.zip
(Downloads: 7781)

WSMonitor is open source licensed under the Mozilla Public License 1.1.

Full source

Update on 08/29/09: Source code is moved to GitHub http://github.com/sectore/wsmonitor/

Acknowledgment

Thanks to Artjom Tarassov, who is one of the smartes Flash programmer I’ve ever met, for the active exchange of ideas during the last weeks ;-) .

]]> http://www.websector.de/blog/2007/10/01/detecting-memory-leaks-in-flash-or-flex-applications-using-wsmonitor/feed/ 19 [Update - Part 2] Logging Flex 2 and AS3 applications with Firebug and ThunderBolt http://www.websector.de/blog/2007/06/20/update-part-2-logging-flex-2-and-as3-applications-with-firebug-and-thunderbolt/ http://www.websector.de/blog/2007/06/20/update-part-2-logging-flex-2-and-as3-applications-with-firebug-and-thunderbolt/#comments Wed, 20 Jun 2007 17:51:00 +0000 sectore http://www.websector.de/blog/2007/06/20/update-part-2-logging-flex-2-and-as3-applications-with-firebug-and-thunderbolt/ This is the second part about the latest update of ThunderBolt AS3. ThunderBolt AS3 is an open source logger extension for Flex 2 or Flash ActionScript 3 applications using Firebug within Firefox.

In part 1 I described a way for using ThunderBolt AS3 with the Flex 2 Logging Framework using an own log target called ThunderBoltTarget. This is a handy extension, but it has a disadvantage: The Flex 2 Logging Framework doesn’t support outputs of nested objects because the original Flex 2 Log instance uses an instance of the LogLogger which dispatches only a message of the logged object typed as String.

For this issue is better to use the ThunderBolt Logger instance directly for logging objects and its nested objects including all properties ;-) . With the latest release I have added a common way for using log levels as well. Check out the the following instructions.

Example

Get Adobe Flash player

 

Screen Shot: Logging to Firebug

Instructions

  1. Grab the latest ThunderBolt AS3 package (includes two classes only) from its repository via SVN on Google Code or download it directly. Make sure that you have installed Firebug as well.

  2. For logging to Firebug call the ThunderBolt Logger class methods such as info, warn, error, debug. You don’t need to create an instance of Logger because all of its public methods and public properties are static.

    Code examples using ThunderBolt

    1. //
    2. // import ThunderBolt Logger
    3. import org.osflash.thunderbolt.Logger;
    4.  
    5. //
    6. // log a string as an info message
    7. var myString: String = "Lorem ipsum";
    8. Logger.info ("A simple string", myString);
    9.  
    10. //
    11. // Log two objects (or more ;-) ) as an error message
    12. var myNumber: int = 5;
    13. var myString2: String = "Lorem ipsum";
    14. Logger.error ("Two log objects: A number typed as int and a string", myNumber, myString2);
    15.  
    16. //
    17. // Log an array with a nested object as a warn message
    18. var myArray: Array = ["firstValue",{x: 100, y: 200}, "secondValue"];
    19. Logger.warn ("An array with a nested object: ", myArray);
    20.  
    21. //
    22. // Log an object with a nested array as a debug message
    23. var myObject: Object = {exampleArray: ["firstValue", "secondValue"], y: 10, exampleString: "Hello", nestedObject: {x: 100, y: 200}};
    24. Logger.debug ("An object with a nested object and nested array", o);
    25.  
    26. //
    27. // Optionally you can hide the time stamp
    28. Logger.includeTime = false;
  3. That’s all – happy logging ;-)

Source

You will find the latest source of the ThunderBolt AS 3 package on Google Code too. It’s open source and based on the Mozilla Public License 1.1.

ThunderBolts core class named “Logger.as” ( Download code )

  1. /**
  2. * Logging Flex and AS3 projects with Firebug using ThunderBolt AS3
  3. *
  4. * @version  0.9.1
  5. * @author   Jens Krause [www.websector.de]
  6. * @date  06/29/07
  7. * @see    http://www.websector.de/blog/?s=thunderbolt
  8. * @see    http://code.google.com/p/flash-thunderbolt/
  9. * @source   http://flash-thunderbolt.googlecode.com/svn/trunk/as3/
  10. *
  11. * ***********************
  12. * HAPPY LOGGING ;-)
  13. * ***********************
  14. *
  15. */
  16.  
  17. package org.osflash.thunderbolt
  18. {
  19.     import flash.external.ExternalInterface;
  20.     import flash.utils.describeType;
  21.     import flash.utils.getQualifiedClassName;
  22.     import flash.utils.getDefinitionByName;
  23.     import mx.logging.LogEventLevel;
  24.     import mx.logging.LogEvent;
  25.  
  26.     /**
  27.     * Thunderbolts AS3 Logger class
  28.     */
  29.     public class Logger
  30.     {
  31.         //
  32.         // Firebug supports 4 log levels only
  33.         protected static const INFO: String = "info";
  34.         protected static const WARN: String = "warn";
  35.         protected static const ERROR: String = "error";
  36.         protected static const LOG: String = "log";
  37.  
  38.         protected static const FIELD_SEPERATOR: String = " :: ";       
  39.         protected static const MAX_DEPTH: int = 255;   
  40.         private static var _stopLog: Boolean = false;
  41.  
  42.         private static var depth: int; 
  43.         private static var logLevel: String;                       
  44.  
  45.         public static var includeTime: Boolean = true; 
  46.  
  47.         /**
  48.          * Logs info messages including objects for calling Firebug
  49.          *
  50.          * @param   msg            log Message
  51.          * @param   logObjects        log objects
  52.          *
  53.          */  
  54.         public static function info (msg: String = null, … logObjects): void
  55.         {
  56.             Logger.trace(LogEventLevel.INFO, msg, logObjects);     
  57.         }
  58.        
  59.         /**
  60.          * Logs warn messages including objects for calling Firebug
  61.          *
  62.          * @param   msg            log Message
  63.          * @param   logObjects        log objects
  64.          *
  65.          */  
  66.         public static function warn (msg: String = null, … logObjects): void
  67.         {
  68.             Logger.trace(LogEventLevel.WARN, msg, logObjects);     
  69.         }
  70.  
  71.         /**
  72.          * Logs error messages including objects for calling Firebug
  73.          *
  74.          * @param   msg            log Message
  75.          * @param   logObjects        log objects
  76.          *
  77.          */  
  78.         public static function error (msg: String = null, … logObjects): void
  79.         {
  80.             Logger.trace(LogEventLevel.ERROR, msg, logObjects);   
  81.         }
  82.        
  83.         /**
  84.          * Logs debug messages messages including objects for calling Firebug
  85.          *
  86.          * @param   msg            log Message
  87.          * @param   logObjects        log objects
  88.          *
  89.          */  
  90.         public static function debug (msg: String = null, … logObjects): void
  91.         {
  92.             Logger.trace(LogEventLevel.DEBUG, msg, logObjects);   
  93.         }      
  94.                 
  95.         /**
  96.          * Calls Firebugs command line API to write log information
  97.          *
  98.          * @param   msg            log Message
  99.          * @param   logObjects        log objects
  100.          */   
  101.         public static function trace (level: Number = 0, msg: String = null, … logObjects): void
  102.         {
  103.             depth = 0;
  104.             // get log level
  105.             logLevel = Logger.getLogLevel(level);
  106.             // add log level to log messagef
  107.             var logMsg: String = "[" + logLevel.toUpperCase() + "] ";
  108.             // add time to log message
  109.             if (includeTime) logMsg += getCurrentTime();
  110.             // add message text to log message
  111.             logMsg += (msg != null && msg.length) ? msg : "";
  112.             // call Firebug            
  113.             ExternalInterface.call("console." + logLevel, logMsg);
  114.             // log objects     
  115.             for (var i:uint = 0; i < logObjects.length; i++)
  116.             {
  117.                 Logger.logObject(logObjects[i]);
  118.             }     
  119.         }
  120.        
  121.         /**
  122.          * Translates Flex log levels to Firebugs log levels
  123.          *
  124.          * @param   msg
  125.          * @return  level description
  126.          *
  127.          */  
  128.         private static function getLogLevel (logLevel: Number): String
  129.         {
  130.             var level: String;
  131.            
  132.             switch (logLevel)
  133.             {
  134.                 case LogEventLevel.INFO:
  135.                     level = Logger.INFO;
  136.                 break;
  137.                 case LogEventLevel.WARN:
  138.                     level = Logger.WARN;
  139.                 break;       
  140.                 case LogEventLevel.ERROR:
  141.                     level = Logger.ERROR;
  142.                 break;
  143.                 // Firebug doesn’t support a fatal level
  144.                 // so we use here Firebugs ERROR level when you’re using ThunderBoltTarget
  145.                 case LogEventLevel.FATAL:
  146.                     level = Logger.ERROR;
  147.                 break;
  148.                 default:
  149.                     // for LogEventLevel.DEBUG && LogEventLevel.ALL
  150.                     // so we use here Firebugs LOG level when you’re using ThunderBoltTarget
  151.                     level = Logger.LOG;
  152.             }
  153.  
  154.             return level;
  155.         }
  156.                
  157.         /**
  158.          * Logs nested instances and properties
  159.          *
  160.          * @param   logObj    log object
  161.          * @param   id        short description of log object
  162.          */ 
  163.         private static function logObject (logObj: *, id: String = null): void
  164.         {   
  165.            
  166.            
  167.             if (depth < Logger.MAX_DEPTH)
  168.             {
  169.                 ++ depth;
  170.                
  171.                 var propID: String = id || "";
  172.                 var description:XML = describeType(logObj);    
  173.                 var type: String = description.@name;
  174.                
  175.                 if (primitiveType(type))
  176.                 {               
  177.                     var msg: String = (propID.length)   ?     "[" + type + "] " + propID + " = " + logObj
  178.                                                         :   "[" + type + "] " + logObj;
  179.                                                            
  180.                     ExternalInterface.call("console." + Logger.LOG, msg);
  181.                 }
  182.                 else if (type == "Object")
  183.                 {
  184.                     ExternalInterface.call("console.group", "[Object] " + propID);                   
  185.                     for (var element: String in logObj)
  186.                     {
  187.                       logObject(logObj[element], element);                 
  188.                     }
  189.                     ExternalInterface.call("console.groupEnd");
  190.                 }
  191.                 else if (type == "Array")
  192.                 {
  193.                     /* don’t create a group on depth 1 when we are using the … (rest) parameter calling by Logger.trace() ;-) */
  194.                     if (depth > 1) ExternalInterface.call("console.group", "[Array] " + propID);                                   
  195.                     for (var i: int = 0; i < logObj.length; i++)
  196.                     {
  197.                       logObject(logObj[i]);            
  198.                     }
  199.                     ExternalInterface.call("console.groupEnd");                    
  200.                 }
  201.                 else
  202.                 {
  203.                     // log private props as well – thx Rob Herman [http://www.toolsbydesign.com] ;-)
  204.                     var list: XMLList = description..accessor;         
  205.                    
  206.                     if (list.length())
  207.                     {
  208.                         for each(var item: XML in list)
  209.                         {
  210.                             var propItem: String = item.@name;
  211.                             var typeItem: String = item.@type;             
  212.                             var access: String = item.@access;
  213.                            
  214.                             // log objects && properties accessing "readwrite" and "readonly" only
  215.                             if (access && access != "writeonly")
  216.                             {
  217.                                 //TODO: filter classes
  218.                                 // var classReference: Class = getDefinitionByName(typeItem) as Class;
  219.                                 var valueItem: * = logObj[propItem];
  220.                                 logObject(valueItem, propItem);
  221.                             }
  222.                         }               
  223.                     }
  224.                     else
  225.                     {
  226.                         logObject(logObj, type);                   
  227.                     }
  228.                 }
  229.  
  230.             }
  231.             else
  232.             {
  233.                 // call one stop message only ;-)
  234.                 if (!_stopLog)
  235.                 {
  236.                     ExternalInterface.call("console." + Logger.WARN, "STOP LOGGING: More than " + depth + " nested objects or properties.");
  237.                     _stopLog = true;
  238.                 }         
  239.             }                           
  240.         }
  241.            
  242.         /**
  243.          * Checking for primitive types
  244.          *
  245.          * @param   type        type of object
  246.          * @return  isPrimitiveType  isPrimitiveType
  247.          *
  248.          */       
  249.         private static function primitiveType (type: String): Boolean
  250.         {
  251.             var isPrimitiveType: Boolean;
  252.            
  253.             switch (type)
  254.             {
  255.                 case "Boolean":
  256.                 case "void":
  257.                 case "int":
  258.                 case "uint":
  259.                 case "Number":
  260.                 case "String":
  261.                 case "undefined":
  262.                 case "null":
  263.                     isPrimitiveType = true;
  264.                 break;     
  265.                 default:
  266.                     isPrimitiveType = false;
  267.             }
  268.  
  269.             return isPrimitiveType;
  270.         }
  271.  
  272.         /**
  273.          * Creates a valid time value
  274.          * @param   number        Hour, minute or second
  275.          * @return  string     A valid hour, minute or second
  276.          */
  277.         
  278.         private static function getCurrentTime ():String
  279.         {
  280.             var currentDate: Date = new Date();
  281.            
  282.             var currentTime: String =   "time "
  283.                                         + timeToValidString(currentDate.getHours())
  284.                                         + ":"
  285.                                         + timeToValidString(currentDate.getHours())
  286.                                         + ":"
  287.                                         + timeToValidString(currentDate.getMinutes())
  288.                                         + ":"
  289.                                         + timeToValidString(currentDate.getSeconds())
  290.                                         + "."
  291.                                         + timeToValidString(currentDate.getMilliseconds()) + FIELD_SEPERATOR;
  292.             return currentTime;
  293.         }
  294.                
  295.         /**
  296.          * Creates a valid time value
  297.          * @param   number        Hour, minute or second
  298.          * @return  string     A valid hour, minute or second
  299.          */
  300.         
  301.         private static function timeToValidString(timeValue: Number):String
  302.         {
  303.             return timeValue > 9 ? timeValue.toString() : "0" + timeValue.toString();
  304.         }
  305.        
  306.        
  307.     }
  308. }
]]> http://www.websector.de/blog/2007/06/20/update-part-2-logging-flex-2-and-as3-applications-with-firebug-and-thunderbolt/feed/ 6 Logging Flex 2 and AS 3 apps with Firebug and ThunderBolt http://www.websector.de/blog/2007/04/21/logging-flex-2-and-as-3-apps-with-firebug-and-thunderbolt/ http://www.websector.de/blog/2007/04/21/logging-flex-2-and-as-3-apps-with-firebug-and-thunderbolt/#comments Sat, 21 Apr 2007 08:40:00 +0000 sectore http://www.websector.de/blog/2007/04/21/logging-flex-2-and-as-3-apps-with-firebug-and-thunderbolt/ A few weeks ago Martin Kleppe started a project on Google Code called Flash-ThunderBolt. The idea behind based on Manfred Webers blog entry “Make MTASC talk to Firebug” which describes a way for logging Flash apps compiled with MTASC using Firebug.

I’ve already joined the Flash-Thunderbolt project for coding an AS3 version. It won’t be a copy of the current AS2 package but rather another approach for using Firebugs Console API as simple as possible. Check it out, here are my first steps:

Example

Get Adobe Flash player

 

Instructions

The ThunderBolt AS3 package contains only one class named Logger.as. It supports logging primitive types such as Number, String, Boolean, etc. as well as Objects, Arrays and public properties of all classes. Use short cuts for determing different log levels as Zeroi does: “i” = info, “e” = error, “w” = warn, “d” = debug.

Here is an example:

ThunderBoltAS3Example.mxml ( Download code )

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">
  3.     <mx:Script>
  4.         <![CDATA[
  5.             import org.osflash.thunderbolt.Logger;
  6.             import flash.events.Event;
  7.             private function traceToFirebug(event:Event):void
  8.             {
  9.                 var n: int = 5;
  10.                 var s: String = "Lorem ipsum";
  11.                 var o: Object = {exampleArray: ["firstValue", "secondValue"], y: 10, exampleString: "Hello", nestedObject: {x: 100, y: 200}};
  12.                 var a: Array = ["firstValue",{x: 100, y: 200}, "secondValue"];
  13.                 var label: String = event.target.label;
  14.                 switch (label)
  15.                 {
  16.                     case "info":
  17.                         Logger.trace ("i a simple string", s);
  18.                     break;
  19.                     case "error":
  20.                         Logger.trace ("i a number typed as int", n);
  21.                     break;
  22.                     case "warn":
  23.                         Logger.trace ("e an array with a nested object: ", a);
  24.                     break;
  25.                     case "debug":
  26.                         Logger.trace ("w an object with a nested object and nested array",o);
  27.                     break;
  28.                     default:
  29.                 }
  30.             }
  31.       ]]>
  32.     </mx:Script>
  33.     <mx:Style source="css/logger.css"/>
  34.     <mx:Text htmlText="Press F12 to open Firebug" paddingBottom="20"/>
  35.     <mx:HBox horizontalGap="10">
  36.          <mx:Button label="info"
  37.                     click="traceToFirebug(event);" id="infoButton" width="100" height="50"/>
  38.          <mx:Button label="error"
  39.                     click="traceToFirebug(event);" id="errorButton" width="100" height="50"/>
  40.          <mx:Button label="warn"
  41.                     click="traceToFirebug(event);" id="warnButton" width="100" height="50"/>
  42.          <mx:Button label="debug"
  43.                     click="traceToFirebug(event);" id="debugButton" width="100" height="50"/>
  44.     </mx:HBox>
  45. </mx:Application>

Source

First of all: Feel free to check out the latest source via SVN ;-) .

Logger.as ( Download code )

  1. /**
  2. * Logging Flex and AS3 projects with Firebug
  3. *
  4. * @author   Jens Krause [www.websector.de]
  5. * @date  04/21/07
  6. * @see  http://www.websector.de/blog/2007/04/21/logging-flex-2-and-as-3-apps-with-firebug-and-thunderbolt/
  7. * @source   http://flash-thunderbolt.googlecode.com/svn/trunk/as3/
  8. *
  9. */
  10. package org.osflash.thunderbolt
  11. {
  12.     import flash.external.ExternalInterface;
  13.     import flash.utils.describeType;
  14.     import flash.utils.getQualifiedClassName;
  15.     import flash.utils.getDefinitionByName;
  16.     /**
  17.     *
  18.     */
  19.     public class Logger
  20.     {
  21.         public static const LOG: String = "log";
  22.         public static const INFO: String = "info";
  23.         public static const WARN: String = "warn";
  24.         public static const ERROR: String = "error";
  25.         private static const MAX_DEPTH: int = 255;
  26.         private static var depth: int;
  27.         private static var logLevel: String;
  28.         /**
  29.          * Calls Firebugs command line API to write log information
  30.          *
  31.          * @param   msg   log Message
  32.          * @param   obj   log object
  33.          */
  34.         public static function trace (msg: String = null, obj:Object = null): void
  35.         {
  36.             depth = 0;
  37.             //
  38.             // log description
  39.             logLevel = (msg != null) ? Logger.getLogLevel(msg) : Logger.LOG;
  40.             var txtMessage: String = (msg != null && msg.length>= 3) ? msg.slice(2) : "";
  41.             var logMsg: String = logLevel.toUpperCase() + ": " + txtMessage;
  42.             ExternalInterface.call("console." + logLevel, logMsg);
  43.             //
  44.             // log object
  45.             if (obj) Logger.logProperties(obj);
  46.         }
  47.         /**
  48.          * Logs nested instances and properties
  49.          *
  50.          * @param   logObj  log object
  51.          * @param   id    short description of log object
  52.          */
  53.         private static function logProperties (logObj: *, id: String = null): void
  54.         {
  55.             ++ depth;
  56.             var propID: String = id || "";
  57.             if (depth <Logger.MAX_DEPTH)
  58.             {
  59.                 var description:XML = describeType(logObj);
  60.                 var type: String = description.@name;
  61.                 if (primitiveType(type))
  62.                 {
  63.                     var msg: String = (propID.length)   ?    "[" + type + "] " + propID + " = " + logObj
  64.                                                         :   "[" + type + "] " + logObj;
  65.                     ExternalInterface.call("console." + Logger.LOG, msg);
  66.                 }
  67.                 else if (type == "Object")
  68.                 {
  69.                     ExternalInterface.call("console.group", "[Object] " + propID);
  70.                     for (var element: String in logObj)
  71.                     {
  72.                       logProperties(logObj[element], element);
  73.                     }
  74.                     ExternalInterface.call("console.groupEnd");
  75.                 }
  76.                 else if (type == "Array")
  77.                 {
  78.                     ExternalInterface.call("console.group", "[Array] " + propID);
  79.                     for (var i: int = 0; i <logObj.length; i++)
  80.                     {
  81.                       logProperties(logObj[i]);
  82.                     }
  83.                     ExternalInterface.call("console.groupEnd");
  84.                 }
  85.                 else
  86.                 {
  87.                     var list: XMLList = description..variable;
  88.                     if (list.length())
  89.                     {
  90.                         for each(var item: XML in list)
  91.                         {
  92.                             var propItem: String = item.@name;
  93.                             var typeItem: String = item.@type;
  94.                             // var ClassReference: Class = getDefinitionByName(typeItem) as Class;
  95.                             var valueItem: * = logObj[propItem];
  96.                             logProperties(valueItem, propItem);
  97.                         }
  98.                     }
  99.                     else
  100.                     {
  101.                         logProperties(logObj, type);
  102.                     }
  103.                 }
  104.             }
  105.             else
  106.             {
  107.                 ExternalInterface.call("console." + Logger.WARN, "STOP LOGGING: More than " + depth + " nested objects or properties");
  108.             }
  109.         }
  110.         /**
  111.          * Checking for primitive types
  112.          *
  113.          * @param   type        type of object
  114.          * @return  isPrimitiveType  isPrimitiveType
  115.          *
  116.          */
  117.         private static function primitiveType (type: String): Boolean
  118.         {
  119.             var isPrimitiveType: Boolean;
  120.             switch (type)
  121.             {
  122.                 case "Boolean":
  123.                     isPrimitiveType = true;
  124.                 break;
  125.                 case "void":
  126.                     isPrimitiveType = true;
  127.                 break;
  128.                 case "int":
  129.                     isPrimitiveType = true;
  130.                 break;
  131.                 case "uint":
  132.                     isPrimitiveType = true;
  133.                 break;
  134.                 case "Number":
  135.                     isPrimitiveType = true;
  136.                 break;
  137.                 case "String":
  138.                     isPrimitiveType = true;
  139.                 break;
  140.                 case "undefined":
  141.                     isPrimitiveType = true;
  142.                 break;
  143.                 case "null":
  144.                     isPrimitiveType = true;
  145.                 break;
  146.                 default:
  147.                     isPrimitiveType = false;
  148.             }
  149.             return isPrimitiveType;
  150.         }
  151.         /**
  152.          * Translates log keys to Firebug log levels,
  153.          * which based on zeroi’s key mapping
  154.          * @see  http://www.osflash.org/zeroi/
  155.          *
  156.          * @param   msg
  157.          * @return  level description
  158.          *
  159.          */
  160.         private static function getLogLevel (msg: String): String
  161.         {
  162.             var firstChar: String = (msg.charAt(1) == " ") ? msg.charAt(0).toLowerCase() : "d";
  163.             var level: String;
  164.             switch (firstChar)
  165.             {
  166.                 case "i":
  167.                     level = Logger.INFO;
  168.                 break;
  169.                 case "w":
  170.                     level = Logger.WARN;
  171.                 break;
  172.                 case "e":
  173.                     level = Logger.ERROR;
  174.                 break;
  175.                 case "d":
  176.                     level = Logger.LOG;
  177.                 break;
  178.                 default:
  179.                     level = Logger.LOG;
  180.             }
  181.             return level;
  182.         }
  183.     }
  184. }

Feedback

Feedback and suggestions for improvement are welcome ;-) If you’d like to join the Flash-ThunderBolt project just drop me an email or feel free to post a comment.

]]> http://www.websector.de/blog/2007/04/21/logging-flex-2-and-as-3-apps-with-firebug-and-thunderbolt/feed/ 3 Extension for Zeroi: XTracePublisher http://www.websector.de/blog/2007/03/12/extension-for-zeroi-xtracepublisher/ http://www.websector.de/blog/2007/03/12/extension-for-zeroi-xtracepublisher/#comments Mon, 12 Mar 2007 03:30:00 +0000 sectore http://www.websector.de/blog/2007/03/12/extension-for-zeroi-xtracepublisher/ Xtrace is a popular debugger console on OS X for logging your trace() data outside the Flash IDE. For easier handling I decided to write an extension for Zeroi that keeps your standard trace() methods in your code.

Here is a screen of a XTrace window receiving Zerois debug messages:

XTrace Window

Instructions

  1. Grab the latest source of Zeroi from its Subversion Repository. You will find there the new extension for XTrace, too.
  2. Download and install XTrace. For enjoying the latest features (e.g. text highlighting) it’s recommended to use the XTrace SVN Repository.
  3. Download the Zeroi example and follow the steps 4 up to 7 described in my previous post called “Debugging with MTASC, Ant and Zeroi”.
  4. Add XTracePublisher as Zerois publisher to MTASC -trace flag. For this purpose you have to change only one line in the Ant script located in my example:
    1. <arg value="-trace"/>
    2. <arg value="org.osflash.Zeroi.logging.LoggerClass.log"/>
    3. <arg value="org/osflash/Zeroi/logging/LoggerClass"/>
    4. <!– point this argument to XTracePublisher –>
    5. <arg value="org/osflash/Zeroi/logging/publisher/XTracePublisher"/>
  5. If you familiar with Terminal you can also create a small shell script to run MTASC instead using Ant. Open Terminal, change directory
    cd {path/to/downloaded/zeroiExample}
    and create a new file named buildpico ./build

    Type then the following line for running MTASC:

    1.  
    2. {path/to/mtasc} -cp {path/to/your/own/core/classes} -cp {path/to/MM/core/classes} -cp {path/to/zeroi/class/package} -cp ./source/ -swf ./deploy/zeroiExample.swf ./ZeroiExample.as -trace org.osflash.Zeroi.logging.LoggerClass.log org/osflash/Zeroi/logging/LoggerClass org/osflash/Zeroi/logging/publisher/XTracePublisher -frame 1 -version 7 -v -main
    3.  
     For opening the *.swf with the FlashPlayer type additionally:

    1.  
    2. open -a SAFlashPlayer ./deploy/zeroiExample.swf
    3.  

    Save the file, close pico and run the script typing ./build

Wish list

  • Adding more log levels, such as “INFO” and “FATAL”. I’ve got in contact with Michael Bianco ;-) .
]]> http://www.websector.de/blog/2007/03/12/extension-for-zeroi-xtracepublisher/feed/ 3 Debugging with MTASC, Ant and Zeroi http://www.websector.de/blog/2007/03/04/debugging-with-mtasc-ant-and-zeroi/ http://www.websector.de/blog/2007/03/04/debugging-with-mtasc-ant-and-zeroi/#comments Sun, 04 Mar 2007 18:43:30 +0000 sectore http://www.websector.de/blog/2007/03/04/debugging-with-mtasc-ant-and-zeroi/ In my previous posts “trace() outside the Flash IDE with tail” and “Are you looking for AFTERTHOUGHT on OS X?” I described two similar ways for debugging Flash movies outside the Flash IDE. In fact, it’s relatively simple to use the Flash Debug Player in connection with the logging file called flashlog.txt but it has only got one big disadvantage: Instead of outputting structured data in predetermined levels you’ll get tons of unstructured lines.

Introduction

A couple of weeks ago, I did this project on a team with Sönke Rohde. He showed me a better way for debugging Flash movies using Zeroi developed by himself and Ralf Bokelberg. Zeroi is a package of classes that supports MTASC’s option for customizing trace() functions and the implementation of different log levels without changing code of your Flash application. You can use it with different debugging tools such as SOS, X-Ray or LuminicBox.Log. One of the most important feature is its ability to broadcast debug messages including additional information about class name, method name, line number and a error level with a standard trace() method.

For example: trace("i This is my message"); will be displayed as MyClass::myMethod Line>> This is my message. Additionally, you can add a character for an error level d = debug, i = info, w = warn, e = error, f = fatal.

Example

Click the buttons below to view the different debug messages.

The movie requires the latest Flash Player.

In this example the LuminicBox.Log is used as a debugger console. Open the LuminicBox.Log only once.

The movie requires the latest Flash Player.

Have a look inside the main class named ZeroiExample.as. It includes only standard trace() methods.

ZeroiExample.as ( Download code )

  1. /**
  2. * ZeroiExample
  3. * @author Jens Krause [www.websector.de]
  4. */
  5. import mx.utils.Delegate;
  6. class ZeroiExample
  7. {
  8.     private static var example: ZeroiExample = null;
  9.     private var __timeline: MovieClip;
  10.     function ZeroiExample(t: MovieClip)
  11.     {
  12.         trace ("i instance of ZeroiExample created");
  13.         __timeline = t;
  14.         initButtons();
  15.     }
  16.     private function initButtons (): Void
  17.     {
  18.         var labels: Array = ["debug", "info", "warn", "error", "fatal"];
  19.         for (var i : Number = 0; i <labels.length; i++)
  20.         {
  21.             var button: MovieClip = __timeline.attachMovie("button", "button" + i, __timeline.getNextHighestDepth(), {id: i, _x: i*100, _y: 30});
  22.             button.label.text = labels[i];
  23.             button.onPress = function () { ZeroiExample.instance.traceExamples(this.id); };
  24.         }
  25.     };
  26.     private function traceExamples ($id: Number): Void
  27.     {
  28.         switch ($id)
  29.         {
  30.             case 0:
  31.                 // this is a debug message
  32.                 trace ("d buttons id => " + $id);
  33.             break;
  34.             case 1:
  35.                 // this is an info message
  36.                 trace ("i buttons id => " + $id);
  37.             break;
  38.             case 2:
  39.                 // this is a warn message
  40.                 trace ("w buttons id => " + $id);
  41.             break;
  42.             case 3:
  43.                 // this is an error message
  44.                 trace ("e buttons id => " + $id);
  45.             break;
  46.             case 4:
  47.                 // this is an fatal message
  48.                 trace ("f buttons id => " + $id);
  49.             break;
  50.             default:
  51.                 trace ("w $id has’nt defined");
  52.         };
  53.     };
  54.     public static function main (t: MovieClip) : Void
  55.     {
  56.         if (ZeroiExample.example == null) ZeroiExample.example = new ZeroiExample(t);
  57.     }
  58. }

For creating the example above I’ve used the following Ant script. In the next chapter I’ll give you detailed instructions to use Zeroi with Ant.

build.xml ( Download code )

  1. <?xml version=’1.0′ encoding="utf-8"?>
  2. <project name="zeroi example" default="run" basedir=".">
  3.     <description>
  4.         buildfile for zeroi‘s example
  5.     </description>
  6.     <target name="deploy" description="Compiles an existing SWF file with MTASC for debugging">
  7.         <!– defines ant properties, you’ll find more properties in "build.jk.properties" –>
  8.         <property name="targetswf" value="zeroiExample.swf"/>
  9.         <property name="mainclass" value="ZeroiExample.as"/>
  10.         <property name="classframe" value="1"/>
  11.         <property name="version" value="7"/>
  12.             <exec executable="${mtasc}" failonerror="true">
  13.                 <!– runs mtasc adding following arguments –>
  14.                 <arg value="-version"/>
  15.                 <arg value="${version}"/>
  16.                 <arg value="-cp"/>
  17.                 <arg value="${content.classpath}"/>
  18.                 <arg value="-cp"/>
  19.                 <arg value="${zeroi.classpath}"/>
  20.                 <arg value="-cp"/>
  21.                 <arg value="${core.classpath}"/>
  22.                 <arg value="-swf"/>
  23.                 <arg value="${deploy.folder}/${targetswf}"/>
  24.                 <arg value="-frame"/>
  25.                 <arg value="${classframe}"/>
  26.                 <arg value="-main"/>
  27.                 <arg value="${content.classpath}/${mainclass}"/>
  28.                 <!– adds zeroi‘s trace functions –>
  29.                 <arg value="-trace"/>
  30.                 <arg value="org.osflash.zeroi.logging.LoggerClass.log"/>
  31.                 <arg value="org/osflash/zeroi/logging/LoggerClass"/>
  32.                 <arg value="org/osflash/zeroi/logging/publisher/LuminicPublisher"/>
  33.             </exec>
  34.         </target>
  35.     <target name="run" depends="deploy" description="opens SWF">
  36.         <!– opens the *.swf with the Flash Player (Standalone) –>
  37.         <!– Note: The following command is for OS X users only, it won’t run on windows –>
  38.         <exec executable="open" dir=".">
  39.             <arg line="-a ${flashplayer.v9} ${deploy.folder}/${targetswf}" />
  40.         </exec>
  41.     </target>
  42. </project>

Instructions

All you need are MTASC, a debugger tool described above, Ant and the Zeroi package. It’s recommend to use Eclipse and FDT as well.

  1. Download the Zeroi example and unzip the file.
  2. Grab the latest Zeroi package and unzip the file.
  3. For this example you’ll need the LuminicBox.Log, too. Download and open it.
    Note: Open the LuminicBox.Log only once.
  4. Make sure, that you have installed MTASC successfully as described on mtasc.org. If you’re on a Mac (PPC or Intel), you’ll find the latest binaries (v.1.13) on MTASC’s mailing list.
  5. Open Eclipse, create a new Flash Project File -> New -> New Flash Project and link it to the folder “Zeroi example”: First you have to uncheck “use default location”. Secondly, browse to the folder where the downloaded example is located.
  6. Customize the property values in build.jk.properties and add this file to Ant’s Preferences on Eclipse: Preferences -> Type “Runtime” in the search field -> Properties -> Add Files
    Note: Windows users have to change the target called “run” located in the build.xml as well. At present, it only runs on OS X. If there’s anyone out there who’s familiar with Ant on windows, feel free to post a comment for this issue.
  7. On Eclipse open the Ant view Window -> Show view -> Ant, drag the build.xml located in the Flash Explorer to its Ant view and press the green button to run the script.

    Eclipse Ant View

  8. If you use other debugger tools, you’ll only have to change one line located in build.xml
    1. // using XRay
    2. <arg value="org/osflash/zeroi/logging/publisher/XRayPublisher"/>
    3. // OR
    4. // using SOS
    5. <arg value="org/osflash/zeroi/logging/publisher/SOSPublisher"/>

Happy debugging ;-)

]]> http://www.websector.de/blog/2007/03/04/debugging-with-mtasc-ant-and-zeroi/feed/ 2 Are you looking for AFTERTHOUGHT on OS X? http://www.websector.de/blog/2007/02/21/are-you-looking-for-afterthought-on-os-x/ http://www.websector.de/blog/2007/02/21/are-you-looking-for-afterthought-on-os-x/#comments Wed, 21 Feb 2007 18:40:44 +0000 sectore http://www.websector.de/blog/2007/02/21/are-you-looking-for-afterthought-on-os-x/ AFTERTHOUGHT is an amazing tool for debugging Flash movies, but it runs only on Windows and it needs .NET runtime. It seems that a Mac version will be available soon but you won’t need it. Because OS X provides a suite of developer tools such as Console which you can view the message logs of your Flash Debug Player in real time as well. If you are familiar with Terminal, you’ll optimize your debugging session as Mark Llobrera commented on Mark Walters’ Blog.

Configure your system as follows:

  1. Install and configure the Flash Debug Player as described in my previous article “trace() outside the Flash IDE with tail”. Follow the steps 1 up to 3 from there.
  2. Start up a Terminal window and change the directory: cd /Users/
  3. Type pico .bash_profile to open Pico and add two aliases named trace and cleartrace inside your .bash_profile located in /Users/[username]/ 
    # opens "flashlog.txt" in Console
alias trace='open -a /Applications/Utilities/Console.app/ /Users/[username]]/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt'
# clears "flashlog.txt"
alias cleartrace='cat /dev/null > /Users/[username]/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt'
  4. Save your .bash_profile, close pico and the shell.
  5. Open a new shell and type trace. The “flashlog.txt” will be opened in Console and will be logged in run time. For searching log messages type a word or phrase in the Filter field.

    Screen Console

    For clearing the “flashlog.txt” type cleartrace.

Happy debugging ;-)

]]> http://www.websector.de/blog/2007/02/21/are-you-looking-for-afterthought-on-os-x/feed/ 2