//------------------------------------------------------------------------------------------------------
// AS3/AIR Extract Image size on file
// V 1.0
//------------------------------------------------------------------------------------------------------
public function GetImageSize(ImageFile : File, Type : String) : Rectangle {
	var Result    : Rectangle  = new Rectangle(0,0,0,0);
	var Bytes     : ByteArray  = new ByteArray();
	var ImgStream : FileStream = new FileStream();
	switch (Type){
		case "bmp" :
			Bytes.endian = Endian.LITTLE_ENDIAN;
			break;
		case "jpg"  :
		case "jpe"  :
		case "jpeg" :
		case "png"  :
		case "gif" :
        		Bytes.endian = Endian.BIG_ENDIAN;
        		break;
        }
	ImgStream.open(ImageFile, FileMode.READ);
	ImgStream.position = 0;
	ImgStream.readBytes(Bytes, 0, ImgStream.bytesAvailable );
	ImgStream.close();
	Bytes.position = 0;
	var ReadInt  : uint   = 0;
	var ReadByte : uint   = 0;
	switch (Type){
		case "jpg"  :
		case "jpe"  :
		case "jpeg" :
			ReadInt = Bytes.readUnsignedShort();
			if ( ReadInt == 0xFFD8 ){
				while(Bytes.position < Bytes.length) {
					ReadByte = Bytes.readUnsignedByte();
					if(ReadByte == 0xFF) {
						ReadByte = Bytes.readUnsignedByte();
						if (ReadByte == 0xC0){
							Bytes.readUnsignedShort(); // Skip section length
							Bytes.readUnsignedByte();  // Skip bit depth
							Result.height = Bytes.readUnsignedShort();
							Result.width  = Bytes.readUnsignedShort();
							break;
						}
					}
				}
			}
			return Result;
        		break;
		case "bmp" :
        		Bytes.readUTFBytes(16);
			Result.width  = Bytes.readUnsignedInt();
			Result.height = Bytes.readUnsignedInt();
        		break;
		case "png" :
        		Bytes.readUTFBytes(16);
			Result.width  = Bytes.readUnsignedInt();
			Result.height = Bytes.readUnsignedInt();
        		break;
		case "gif" :
			var SGTC : int = 0;
			ReadInt = Bytes.readUnsignedInt();
			if (ReadInt == 0x47494638 ) {
				Bytes.readUnsignedShort(); 				// Skip 2 last chars '7a" or "9a"
				Bytes.readUnsignedShort();   				// Skip ScreenWidth
				Bytes.readUnsignedShort();   				// Skip ScreenHeight
				var HeaderFlags : int = Bytes.readUnsignedByte();   	// Get Flags
				Bytes.readUnsignedByte();   				// Skip Background Color Index
				Bytes.readUnsignedByte();   				// Skip Pixel Aspect Ratio

				if ( (HeaderFlags & 0x1) > 0 ) {
					HeaderFlags = (HeaderFlags >> 5 ) & 0x07 ;
					SGTC = 3 * Math.pow(2,( HeaderFlags + 1));
					if ( ( Bytes.position + SGTC ) < Bytes.length){
						Bytes.position = Bytes.position + SGTC;
					} else {
						break;
					}
				}
				while(Bytes.position < Bytes.length) {
					ReadByte = Bytes.readUnsignedByte();
					if ( ReadByte == 0x2C ){
						Bytes.readUnsignedShort();   // Skip Left
						Bytes.readUnsignedShort();   // Skip Top
						Result.width  = Bytes.readUnsignedByte() + 256 * Bytes.readUnsignedByte();
	 					Result.height = Bytes.readUnsignedByte() + 256 * Bytes.readUnsignedByte();
	 					break;
					} else if ( ReadByte == 0x21 ){
						while(Bytes.position < Bytes.length) {
							ReadByte = Bytes.readUnsignedByte();
							if ( ReadByte == 0x00 ) break; // Search Block Terminator
						}
					}
				}
			}
        		break;
        }
        return Result;
}

//------------------------------------------------------------------------------------------------------
// AS3/AIR Image detection with unknow file type extention.
// V 1.0
//------------------------------------------------------------------------------------------------------
public function GetImageFileType(TestFile : File) : String {
	var extention : String     = "";
        var Bytes     : ByteArray  = new ByteArray();
	var BmpStream : FileStream = new FileStream();
	Bytes.endian = Endian.LITTLE_ENDIAN;
	BmpStream.open(TestFile, FileMode.READ);
	BmpStream.position = 0;
	BmpStream.readBytes(Bytes, 0, 8 );
	BmpStream.close();
	//-------------------------------------------------------
	var signature : int = Bytes.readShort();
	if (signature == 0x4D42) {
		extention = "bmp";
	} else {
		Bytes.position = 0;
		signature = Bytes.readInt()& 0xFFFFFF;
		if (signature == 0xFFD8FF) {
			extention = "jpg";
		} else {
			Bytes.position = 0;
			signature = Bytes.readInt()& 0xFFFFFFFF;
			if (signature == 0x38464947  ) {
				extention = "gif";
			} else {
				Bytes.position = 0;
				signature = Bytes.readInt();
				if (signature == 0x474E5089 ) {
					signature = Bytes.readInt();
					if (signature == 0x0A1A0A0D ) {
						extention = "png";
					}
				}
			}
		}
	}
        return extention;
}

A view of result :

Preliminary :
To make a pie must first have data to display, and perform an array dedicated to the creation of the pie.

First look at the type of data contained in your array, it could be for example:

//
//  Class_Item.h
//
@interface Your_Array_Item : NSObject {
	NSString* time;
	NSString* ip;
	NSString* system;
	NSString* browser;
	NSString* version;
	NSString* resolution;
	NSString* language;
	NSString* referer;
	NSString* isp;
}

@property (nonatomic, retain) NSString* time;
@property (nonatomic, retain) NSString* ip;
@property (nonatomic, retain) NSString* system;
@property (nonatomic, retain) NSString* browser;
@property (nonatomic, retain) NSString* version;
@property (nonatomic, retain) NSString* resolution;
@property (nonatomic, retain) NSString* language;
@property (nonatomic, retain) NSString* referer;
@property (nonatomic, retain) NSString* isp;

@end

//
//  Class_Item.m
//
#import "Class_Item.h"
@implementation Your_Array_Item
@synthesize time;
@synthesize ip;
@synthesize system;
@synthesize browser;
@synthesize version;
@synthesize resolution;
@synthesize language;
@synthesize referer;
@synthesize isp;
@end

Then look at the type of data contained in our array for display:

//
//  Class_Array_Item.h
//
@interface Array_Item_To_Show: NSObject {
	NSString* Info;      // Title of the pie part
	UIColor*  Color;     // Color of the pie part
	double    Percent;   // percent of the pie part ( 0.33 => 33% )
	double    CountItem; // the number of similare item found, this number is for percent calculation
}

@property (nonatomic, retain) NSString* Info;
@property (nonatomic, retain) UIColor*  Color;
@property double  Percent;
@property double  CountItem;
@end

//
//  Class_Array_Item.m
//
#import "Class_Array_Item.h"
@implementation Array_Item_To_Show
@synthesize Info;
@synthesize Color;
@synthesize Percent;
@synthesize CountItem;
@end

In your view controller (or other) you must define this

@interface YourViewController : UIViewController {
...
NSMutableArray*  YourDataArray; // Your data array
NSMutableArray*  PieItemArray;  // Array of Array_Item_To_Show
...
}

and initialize to avoid exeption !

- (void) viewDidLoad {
...
YourDataArray = [[NSMutableArray arrayWithCapacity:0] retain];
PieItemArray  = [[NSMutableArray arrayWithCapacity:0] retain];
...
}

To convert YourDataArray to PieItemArray you can write this fuction

//------------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------------
- (UIColor*) GetRandomColor
{
	CGFloat red   = (CGFloat)random()/(CGFloat)RAND_MAX;
	CGFloat blue  = (CGFloat)random()/(CGFloat)RAND_MAX;
	CGFloat green = (CGFloat)random()/(CGFloat)RAND_MAX;
	return [UIColor colorWithRed: red green: green blue: blue alpha: 1.0];
}
//------------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------------
- (BOOL) CheckIfExistInArray : (NSArray*) Array : (NSString*) Search
{
	for (int i=0; i < Array.count; i++){
		Array_Item_To_Show* Item = [Array objectAtIndex:i];
		if ( [Item.Info isEqualToString: Search] ){
			[[Array objectAtIndex:i] setCountItem: [[Array objectAtIndex:i] CountItem] + 1];
			return YES;
		}
	}
	return NO;
}
//------------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------------
- (void) GetFinalArray : (NSString*) ItemFieldName
{
	int i;

	//--------------------------------------------------------------------------
	// declaration of new temp array for result
	NSMutableArray* TmpArray = [[NSMutableArray arrayWithCapacity:0] retain];

	//--------------------------------------------------------------------------
	// declaration of your array count item
	int ArrayCountValue = DataArray.count;

	//--------------------------------------------------------------------------
	// declaration of Temp item to add in TmpArray
	Array_Item_To_Show* NewItem;

	//--------------------------------------------------------------------------
	// declaration of your array item type
	Your_Array_Item* YourArrayItem;

	//--------------------------------------------------------------------------
	// declaration of Percent number
	NSNumber* Percent;

	//--------------------------------------------------------------------------
	// get all symilarity item and count
	//--------------------------------------------------------------------------
	for (i = 0; i < ArrayCountValue; i++){
		YourArrayItem = [YourDataArray objectAtIndex:i];

		if ( [self CheckIfExistInArray: TmpArray : [YourArrayItem valueForKey: ItemFieldName] ] == NO ){

			//--------------------------------------------------------------------------
			// add item if not exists !
			NewItem = [Array_Item_To_Show alloc];
			[NewItem setInfo: [YourArrayItem valueForKey:ItemFieldName] ];
			[NewItem setCountItem: 1];
			[TmpArray addObject: NewItem];
		}
	}
	//--------------------------------------------------------------------------
	// Compute percent for each items
	//--------------------------------------------------------------------------
	for (i=0; i < TmpArray.count; i++){
		NewItem = [TmpArray objectAtIndex:i];
		Percent = [NSNumber numberWithFloat:( 360 * (NewItem.CountItem / ArrayCountValue) )];

		//--------------------------------------------------------------------------
		// Assign a percent to pie part
		[NewItem setPercent: [Percent floatValue]];

		//--------------------------------------------------------------------------
		// Assign a color to pie part
		[NewItem setColor: [self GetRandomColor]];
	}
	//--------------------------------------------------------------------------
	// empty the final array that contain result
	[PieItemArray removeAllObjects];

	//--------------------------------------------------------------------------
	// Sort result array by percent
	NSSortDescriptor* Descriptor = [[[NSSortDescriptor alloc] initWithKey:@"Percent" ascending: NO] autorelease];

	//--------------------------------------------------------------------------
	// finally fill the final array with the sorted temp array
	[PieItemArray addObjectsFromArray: [TmpArray sortedArrayUsingDescriptors:[NSArray arrayWithObject: Descriptor]]];
}

The function to draw a pie chart with PieItemArray is show bellow :

//------------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------------
- (UIImage*) DrawPieWithArray : (CGFloat) PieRadius : (CGFloat) TopLeftBorder
{
	CGFloat CenterX   = PieRadius + TopLeftBorder;
	CGFloat CenterY   = PieRadius + TopLeftBorder;
	CGFloat StartRad  = 0;
	CGFloat EndRad    = 0;
	//---------------------------------------------------------------------------------------
	CGColorSpaceRef _ColorSpace  = CGColorSpaceCreateDeviceRGB();
	CGContextRef    _ViewContext = CGBitmapContextCreate (NULL,  2*CenterX, 2*CenterY, 8, 0, _ColorSpace, kCGImageAlphaPremultipliedLast);
	if (_ViewContext == NULL){
		CGColorSpaceRelease(_ColorSpace);
		return nil;
	}
	//---------------------------------------------------------------------------------------
	CGContextSetRGBStrokeColor(_ViewContext, 1.0, 1.0, 1.0, 1.0);
	CGContextSetLineWidth(_ViewContext, 4.0);
	//---------------------------------------------------------------------------------------
	for (NSUInteger i = 0; i< PieItemArray.count; i++){
		Array_Item_To_Show* Item = [PieItemArray objectAtIndex:i];

		//-------------------------------------------------------------
		// set the pie part color
		const CGFloat* RGBComponents = CGColorGetComponents( [Item.Color CGColor] );
		CGContextSetRGBFillColor(_ViewContext, RGBComponents[0], RGBComponents[1], RGBComponents[2], 1.0 );

		//-------------------------------------------------------------
		// Compute the finale angle for the pie part arc
		EndRad = StartRad + Item.Percent;

		//-------------------------------------------------------------
		// draw the pie part
		CGContextMoveToPoint(_ViewContext, CenterX, CenterY);
		CGContextAddArc(_ViewContext, CenterX, CenterY, PieRadius,  radians(StartRad), radians(EndRad), 0);
		CGContextClosePath(_ViewContext);
		CGContextFillPath(_ViewContext);

		StartRad = EndRad;
	}

	//--------------------------------------------------------------------------------------
	// Option : to improve rendering, you can add an overlay image on the top of the pie
	// See bellow for image example.
	CGImageRef OverlayImage = [[UIImage imageNamed: @"cam_overlay.png" ] CGImage];
	CGContextDrawImage(_ViewContext, CGRectMake( 0.0,  0.0, CGImageGetWidth(OverlayImage), CGImageGetHeight(OverlayImage) ), OverlayImage);	

	//---------------------------------------------------------------------------------------
	// Create UIImage with context
	CGImageRef _BitmapContext = CGBitmapContextCreateImage(_ViewContext);
	UIImage* Result           = [UIImage imageWithCGImage: _BitmapContext];

	//---------------------------------------------------------------------------------------
	// free all resource !
	CGContextRelease(_ViewContext);
	CGColorSpaceRelease(_ColorSpace);
	CGImageRelease(_BitmapContext);
	return Result;
}

Bellow an example of overlay image used with LinkLite :

Finally to get a visual result you must :

1 – Fill your DataArray

2 – Call « GetFinalArray » function like this to show a pie chart with browser item for example !

[self GetFinalArray : @"browser"];

3 – Call « DrawPieWithArray » function and fill your image with the result

[your_Pie_img  setImage: [self DrawPieWithArray : 60.0 : 6.0]];

Now you are ready to show pie chart on your iPhone / iPad / iPod !

Some screenshots:

Unfortunately, this application has not been completed but is functional, so if you introduce the courage to finish it, it will gladly, I’ll post the update here!

You can download the application and the sources here:

WhatYouTake Source
WhatYouTake Air

WhatYouSee is a Wysiwyg editor (What You See Is What You Get!) to generate a PDF file. This application also have an image editor.
This application uses largely an excellent AS3 class developed by bytearray.org: alivepdf.

Some screenshots:

Unfortunately, this application has not been completed, so if you introduce the courage to finish it, it will gladly, I’ll post the update here!
You can download the application and the sources here:

WhatYouSee AS3 Source
WhatYouSee AIR Application

Some screenshots:

It would take too long to explain the principle in detail, however small diagram below gives you an idea of its operation.
Note that all modules have common methods (the principle of the plugin) called by the main application:

For all modules and script:

getModuleInfo :

Method returning the parameters of the plugin configuration form of XML:

• « IsMainModule » : Indicates whether this is the main module
• « MinHeight » : Minimum height for the interface
• « MinWidth » : Minimum width for the interface
• « Resizable » : True or False if the interface is resizable
• « HasDrawer » : If the interface has a drawer options
• « DrawerName » : If HasDrawer = true, the name of the module options

or null if there is a « script background »!

getModuleReady :
Returns True or False if the module to be initialized finished and ready for use.

ExecuteCommand :

• Command: String (Command Name)
• Data : Object (parameters)

The icing on the cake: We’ve added the ability to run a background script if the module does not run !

You can download the sources here :
MagicToolbox Source
MagicToolbox AIR

The principle is very simple, the system consists of two distinct parts:

• Server for graphic web page capture (written in Delphi and based on Internet Explorer activeX).
• browser (to facilitate testing I wrote a client in Flex-AIR to automate the server protocol).

The server:

After you learn the IP and port used, simply start the server, and that’s all. The other parameters are there to fix more precisely how it works.
However, I have included the ability to retouch coarsely catches.

Some screenshots:

Web browser:

For a snapshot from the server, there are three things to do:

1 / Create a query capture :

To do this, simply call with your favorite browser, this type of application:
http://YourIP:YourPort/index.html?Action=SetCapture&Url=http://www.free.fr &SrcWidth=953&SrcHeight=1235&Static=true&CaptureDelay=0& …
To Server :
‘Action’ = ‘SetCapture’ => Needed
‘Url’ => String of Url to capture => Needed
‘SrcWidth’ => Integer : Width of original Web page => Needed
‘SrcHeight’ => Integer : Height of original Web page => Needed
‘Static’ => Boolean (‘true’ or ‘false’) => Default = true
‘EmptyCache’ => Boolean (‘true’ or ‘false’) => Default = true
if Static = false
‘CaptureDelay’ => Integer : Delay before screenshot after page completed => Default = 0
‘OffsetTop’ => Integer => Default = 0
‘OffsetLeft’ => Integer => Default = 0
‘OffsetBottom’ => Integer => Default = 0
‘OffsetRight’ => Integer => Default = 0
‘Quality’ => Integer => Default = 75 (%)
‘Zoom’ => Decimal : Zoom factor (0.1..500) => Default = 1
From Server :
xml => <result><action>SetCapture</action><data>D1B831BF76B56038A6B0ADD3DDD663BA</data></result>

« D1B831BF76B56038A6B0ADD3DDD663BA » is a single value returned by the server, used to identify your request.

2 / Ensure that the catch has been made :

To do this simply call, this request containing the ID provided by the first query:

http://YourIP:YourPort/index.html?Action=IsCaptureReady&Id=D1B831BF76B56038A6B0ADD3DDD663BA

To Server :
‘Action’ = ‘IsCaptureReady’
‘Id’ => String => Needed
From Server :
xml => <result><action>IsCaptureReady</action><data>(‘true’or ‘false’)</data></result>

3 /Finally, if the answer is positive, download the image with the following query :

http://YourIP:YourPort/index.html?Action=GetCapture&Id=D1B831BF76B56038A6B0ADD3DDD663BA

To Server :
‘Action’ = ‘GetCapture’
‘Id’ => String => Needed
From Server :
JPG => Image File

The AIR application:

It will manage (in an automatic way to catch) and interrogate the server, whether the final image is ready to be downloaded, and finally display the result.

As always, it is the spirit of this blog, you will find various files to download below:
Server Source
Server Windows exe.
Viewer source
Viewer AIR

Overview of results:

First talk, the class defining the type of data to draw:

package com.gafmedia.Graph;
package com.gafmedia.Graph;
public class PieItem {
	public int Count;
	public String Label;
	public float Percent;
	public int Color;
}

In the case of our application, we have:
Count : Represents the number to display in our pie, knowing that it will be divided by the total number to form the percentage.
Label : The title of the portion of the pie.
Percent : The percentage of the total. (Not used yet!).
Color : The color of the portion of pie.

A graph is composed of several points, they will be placed in an array of type:

List<PieItem> PieData = new ArrayList<PieItem>(0);

To fill this table you can use, for example, a loop like this:

...
PieItem Item;
Random mNumGen = new Random();
int MaxPieItems = mNumGen.nextInt(20);
int ItemValue;
//-----------------------------------------------------------
// MaxCount nous servira plus tard et représente la somme
// de tous les ItemValue pour calculer le pourcentage.
//-----------------------------------------------------------
int MaxCount = 0;
for (int i = 0; i < MaxPieItems ; i++) {
	ItemCount  = mNumGen.nextInt(256);
	Item       = new PieItem();
	Item.Count = ItemCount
	Item.Label = "Valeur " + mNumGen.nextInt(1000);
	Item.Color = 0xff000000 + 256*256*mNumGen.nextInt(256) + 256*mNumGen.nextInt(256) + mNumGen.nextInt(256);
	PieData.add(Item);
	MaxCount += ItemCount;
}
...

Once your table is full, you create your graph to handle it as follows:

...
//-----------------------------------------------
// OverlayId  =>Image qui sera dessinée au dessus
// du camembert pour le rendre plus jolie !!!
//-----------------------------------------------
int OverlayId = R.drawable.cam_overlay_big;

View_PieChart PieChartView = new View_PieChart( this );
PieChartView.setLayoutParams(new LayoutParams(Size, Size));
PieChartView.setGeometry(Size, Size, 5, 5, 5, 5, OverlayId);
PieChartView.setSkinParams(BgColor);
PieChartView.setData(data, MaxCount);
PieChartView.invalidate();
...

Explanation of used methods:

public void setGeometry(int width, int height, int GapLeft, int GapRight, int GapTop, int GapBottom, int OverlayId) {
...
}

This method defines the geometric parameters of your View: Size (width, height) of your View, and then the border settings (GapLeft, GapRight, GapTop, GapBottom) and finally

(OverlayId) the ID of an image will be placed on top of pie, to improve the rendering. This method is called before anything else!.

public void setSkinParams(int bgColor){
...
}

The second method is called, defines the different display settings (bgColor) background color.

public void setData (List<PieItem> data, int MaxConnection) {
..
}

The last method defined values of the graph, and the number used to calculate the maximum percentage of each share. Calling this method unlocks the method OnDraw(), avoiding throwing

an exception if the data are not defined.

Finally, here is the class View_PieChart.java, to include in your application:

package com.gafmedia.Graph;

import com.gafmedia.Graph.PieItem;
import java.util.List;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.BitmapFactory.Options;
import android.util.AttributeSet;
import android.view.View;

public class View_PieChart extends View {
	private static final int WAIT = 0;
	private static final int IS_READY_TO_DRAW = 1;
	private static final int IS_DRAW = 2;
	private static final float START_INC = 30;
	private Paint mBgPaints   = new Paint();
	private Paint mLinePaints = new Paint();
	private int   mOverlayId;
	private int   mWidth;
	private int   mHeight;
	private int   mGapLeft;
	private int   mGapRight;
	private int   mGapTop;
	private int   mGapBottom;
	private int   mBgColor;
	private int   mState = WAIT;
	private float mStart;
	private float mSweep;
	private int   mMaxConnection;
	private List<PieItem> mDataArray;
	//--------------------------------------------------------------------------------------
	public View_PieChart (Context context){
		super(context);
	}
	//--------------------------------------------------------------------------------------
	public View_PieChart(Context context, AttributeSet attrs) {
        super(context, attrs);
	}
	//--------------------------------------------------------------------------------------
	@Override
	protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		//------------------------------------------------------
		if (mState != IS_READY_TO_DRAW) return;
		canvas.drawColor(mBgColor);
		//------------------------------------------------------
		mBgPaints.setAntiAlias(true);
		mBgPaints.setStyle(Paint.Style.FILL);
		mBgPaints.setColor(0x88FF0000);
		mBgPaints.setStrokeWidth(0.5f);
		//------------------------------------------------------
		mLinePaints.setAntiAlias(true);
		mLinePaints.setStyle(Paint.Style.STROKE);
		mLinePaints.setColor(0xff000000);
		mLinePaints.setStrokeWidth(0.5f);
		//------------------------------------------------------
		RectF mOvals = new RectF( mGapLeft, mGapTop, mWidth - mGapRight, mHeight - mGapBottom);
		//------------------------------------------------------
		mStart = START_INC;
		PieItem Item;
		for (int i = 0; i < mDataArray.size(); i++) {
			Item = (PieItem) mDataArray.get(i);
			mBgPaints.setColor(Item.Color);
			mSweep = (float) 360 * ( (float)Item.Count / (float)mMaxConnection );
			canvas.drawArc(mOvals, mStart, mSweep, true, mBgPaints);
			canvas.drawArc(mOvals, mStart, mSweep, true, mLinePaints);
			mStart += mSweep;
		}
		//------------------------------------------------------
		Options options = new BitmapFactory.Options();
		options.inScaled = false;
		Bitmap OverlayBitmap = BitmapFactory.decodeResource(getResources(), mOverlayId, options);
		canvas.drawBitmap(OverlayBitmap, 0.0f, 0.0f, null);
		//------------------------------------------------------
		mState = IS_DRAW;
	}
	//--------------------------------------------------------------------------------------
	public void setGeometry(int width, int height, int GapLeft, int GapRight, int GapTop, int GapBottom, int OverlayId) {
		mWidth     = width;
		mHeight    = height;
		mGapLeft   = GapLeft;
		mGapRight  = GapRight;
		mGapTop    = GapTop;
		mGapBottom = GapBottom;
		mOverlayId = OverlayId;
	}
	//--------------------------------------------------------------------------------------
	public void setSkinParams(int bgColor) {
		mBgColor   = bgColor;
	}
	//--------------------------------------------------------------------------------------
	public void setData(List<PieItem> data, int MaxConnection) {
		mDataArray = data;
		mMaxConnection = MaxConnection;
		mState = IS_READY_TO_DRAW;
	}
	//--------------------------------------------------------------------------------------
	public void setState(int State) {
		mState = State;
	}
	//--------------------------------------------------------------------------------------
	public int getColorValue( int Index ) {
		if (mDataArray == null) return 0;
		if (Index < 0){
			return ((PieItem)mDataArray.get(0)).Color;
		} else if (Index >= mDataArray.size()){
			return ((PieItem)mDataArray.get(mDataArray.size()-1)).Color;
		} else {
			return ((PieItem)mDataArray.get(mDataArray.size()-1)).Color;
		}
	}
}

As always, you can download all files HERE .

(14-12-2010) UPDATE :
I add an ANDROID sample with this class, you can download it HERE.

Overview of results:

First talk, the class defining the type of data to draw:

package com.gafmedia.Graph;
public class LineChartItem {
	public String Date;
	public int Connection;
}

In the case of our application, we have: X: Date (String), and Y: Connect (int).

A graph is composed of several points, they will be placed in an array of type :

List<LineChartItem> LineChartArray = new ArrayList<LineChartItem>(0);

To fill this table you can use, for example, a loop like this:

...
for (int i = StartIndex; i < EndIndex; i++) {
	ItemNode   = (Element) AllNodes.item(i);
	Day        = ItemNode.getAttribute("day");
	Month      = ItemNode.getAttribute("month");
	Year       = ItemNode.getAttribute("year");
	try {
		Connection = NumberFormater.parse(ItemNode.getAttribute("value")).intValue();
	} catch (java.text.ParseException e) {
		e.printStackTrace();
	}
	ChartItem = new LineChartItem();
	ChartItem.Date = Day + "-" + Month + "-" + Year;
	ChartItem.Connection = Connection;
	LineChartArray.add(ChartItem);
}
...

Once your table is full, you create your graph to handle it as follows:

...
View_LineChart mTmpChartView = new View_LineChart(this);
mTmpChartView.setGeometry(mHolderWidth, mHolderHeight, CHART_LEFT_GAP, CHART_RIGHT_GAP, CHART_GAP_TOP, CHART_GAP_BOTTOM);
if(mWhiteGraph == true){
	mTmpChartView.setSkinParams(mWhiteBgColor, mWhiteGridColor, mWhiteLineColor, mWhiteTxtColor, mFillGraph, mAverageLine, mZoomChart);
} else {
	mTmpChartView.setSkinParams(mBlackBgColor, mBlackGridColor, mBlackLineColor, mBlackTxtColor, mFillGraph, mAverageLine, mZoomChart);
}
mTmpChartView.setData(LineChartArray, mUrl);
mTmpChartView.invalidate();
...

Explanation of used methods:

public void setGeometry(int width, int height, int GapLeft, int GapRight, int GapTop, int GapBottom) {
...
}

This method defines the geometric parameters of your View: size (width, height), then the border settings (GapLeft, GapRight, GapTop, GapBottom). This method is called before anything

else!.

public void setSkinParams(int bgColor, int gridColor, int lineColor, int textColor, boolean FillGraph, boolean AverageLine, boolean ZoomChart) {
...
}

The second method is called, defines the various display settings, first the different colors to use (bgColor (background), GridColor (Grid), LineColor (Line), textColor (Text)), then

the different things to show or not: (FillGraph) indicates whether the graph is full, or just display as a line (AverageLine) indicates whether the line of average values of Y is

shown or not, and finally (ZoomChart) indicates whether the graph from scratch Also on display or if it is between the minimum and maximum value of Y.

public void setData( List<LineChartItem> ChartArray, String  Url) {
..
}

The last method defined values of the graph. Calling this method unlocks the method OnDraw (), avoiding throwing an exception if the data are not defined.

Finally, here is the class View_LineChart.java, to include in your application:

package com.gafmedia.Graph;

import com.gafmedia.Graph.LineChartItem;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.View;

public class View_LineChart extends View {
	public static final int LABEL_X_SHOW = 7;
	public static final int LABEL_Y_SHOW = 6;

	private Canvas mCanvas          = null;
	private Paint  mBGPaint         = new Paint();
	private Paint  mLinePaint       = new Paint();
	private Paint  mGridPaintFull   = new Paint();
	private Paint  mGridPaintDot    = new Paint();
	private Paint  mTitlePaint      = new Paint();
	private Paint  mAveragePaint    = new Paint();
	private Paint  mAverageTxtPaint = new Paint();

	private boolean  isReadyToDraw = false;

	private int      mWidth;
	private int      mHeight;
	private boolean  mFillGraph;
	private boolean  mAverageLine;
	private boolean  mZoomChart;

	private int      mGapLeft;
	private int      mGapRight;
	private int      mGapTop;
	private int      mGapBottom;

	private int      mBgColor;
	private int      mGridColor;
	private int      mLineColor;
	private int      mTextColor;

	private String   mUrl;
	List<LineChartItem> mLineChartArray = new ArrayList<LineChartItem>();
	//--------------------------------------------------------------------------------------
	public View_LineChart (Context context){
		super(context);
	}
	//--------------------------------------------------------------------------------------
	public View_LineChart(Context context, AttributeSet attrs) {
        super(context, attrs);
	}
	//--------------------------------------------------------------------------------------
	@Override
	protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		if (isReadyToDraw == false) return;
		mCanvas = canvas;
		//--------------------------------------------------------------------------
		mBGPaint.setStyle(Paint.Style.FILL);
		mBGPaint.setColor(mBgColor);
		mCanvas.drawPaint(mBGPaint);
		//--------------------------------------------------------------------------
		mLinePaint.setColor(mLineColor);
		if (mFillGraph == true){
			mLinePaint.setStyle(Paint.Style.FILL_AND_STROKE);
		} else {
			mLinePaint.setStyle(Paint.Style.FILL);
		}
		mLinePaint.setAntiAlias(true);
		mLinePaint.setStrokeWidth(1.5f);
		//--------------------------------------------------------------------------
		mGridPaintDot.setColor(mGridColor);
		mGridPaintDot.setAntiAlias(false);
		mGridPaintDot.setStyle(Paint.Style.STROKE);
		mGridPaintDot.setStrokeWidth(0.5f);
		mGridPaintDot.setPathEffect( new DashPathEffect(new float[] {5,5 }, 1) );
		//--------------------------------------------------------------------------
		mGridPaintFull.setColor(mGridColor);
		mGridPaintFull.setAntiAlias(false);
		mGridPaintFull.setStyle(Paint.Style.STROKE);
		mGridPaintFull.setStrokeWidth(1.0f);
		//--------------------------------------------------------------------------
		mTitlePaint.setStyle(Paint.Style.FILL);
		mTitlePaint.setTextAlign(Paint.Align.LEFT);
		mTitlePaint.setColor(mTextColor);
		mTitlePaint.setTextSize(10);
		//--------------------------------------------------------------------------
		Rect TextRect = new Rect();
		//----------------------------------------------------------------------------------
		// Get Y Max Values
		//----------------------------------------------------------------------------------
		String StrLablel;
		LineChartItem ChartItem;
		float y;
		int   Index;
		int   value;
		float OldX;
		float OldY;
		float NewX;
		float NewY;
		int   maxY         = 0;
		int   minY         = 0;
		int   ValuesCount  = mLineChartArray.size();
		float graphAverage = 0;
		//----------------------------------------------------------------------------------
		// GET Y MIN & MAX
		//----------------------------------------------------------------------------------
		for (int i = 0; i<ValuesCount; i++){
			ChartItem = mLineChartArray.get(i);
			if (maxY < ChartItem.Connection) maxY = ChartItem.Connection;
			graphAverage += ChartItem.Connection;
		}
		if (mZoomChart == true){
			minY = maxY;
			for (int i = 0; i<ValuesCount; i++){
				ChartItem = mLineChartArray.get(i);
				if (minY > ChartItem.Connection) minY = ChartItem.Connection;
			}
		} else {
			minY = 0;
		}
		graphAverage = graphAverage / (float)ValuesCount;
		//----------------------------------------------------------------------------------
		// DRAW Y AXIS
		//----------------------------------------------------------------------------------
		float step  = (float) (maxY - minY) / (float) (LABEL_Y_SHOW);
		float stepY = (float) (mHeight - mGapTop - mGapBottom) / (float) (maxY - minY);
		for (int i = 0; i <= LABEL_Y_SHOW ; i++) {
			y = (float) ((i * step) * stepY);
			OldX = (float) (mGapLeft - 2);
			OldY = (float) (mHeight - mGapBottom - y);
			NewX = (float) (mWidth - mGapRight);
			NewY = (float) (mHeight - mGapBottom - y);
			if (i == 0) mCanvas.drawLine(OldX, OldY, NewX, NewY, mGridPaintFull);
			else  mCanvas.drawLine(OldX, OldY, NewX, NewY, mGridPaintDot);
			//----------------------------------------------------------------------
			value     = (int) minY + (int)(i * step);
			StrLablel = "" + value;
			mCanvas.drawText(StrLablel, 2, NewY, mTitlePaint);
		}
		//----------------------------------------------------------------------------------
		// DRAW X AXIS
		//----------------------------------------------------------------------------------
		float stepX     = (float) (mWidth - mGapLeft - mGapRight) / (float) (LABEL_X_SHOW - 1);
		float IndexStep = (float) ValuesCount / (float) LABEL_X_SHOW;
		NewY = (float)(mHeight - mGapBottom);
		String[] DateItem = new String[3];
		for (int j = 0; j<LABEL_X_SHOW; j++){
			Index = (int) ((float)(j)* (float)IndexStep);
			if (Index >= ValuesCount) Index = ValuesCount - 1;
			if (j == LABEL_X_SHOW -1) Index = ValuesCount - 1;
			NewX = (float)( (float) mGapLeft +  (float)(j*stepX) );
			//--------------------------------------------------------------------------
			if (j == 0) mCanvas.drawLine(NewX, mGapTop, NewX, NewY+3, mGridPaintFull);
			else  mCanvas.drawLine(NewX, mGapTop, NewX, NewY+3, mGridPaintDot);
			//--------------------------------------------------------------------------
			ChartItem = mLineChartArray.get(Index);
			DateItem  = ChartItem.Date.split("-");
			StrLablel = DateItem[0] + "-" + DateItem[1];
			mTitlePaint.getTextBounds(StrLablel, 0, StrLablel.length(), TextRect);
			NewX = NewX - TextRect.right/2;
			mCanvas.drawText(StrLablel, NewX, (mHeight - mGapBottom) + 13, mTitlePaint);
		}
		//--------------------------------------------------------------------------
		// Draw Graph Lines
		//--------------------------------------------------------------------------
		float pointStepX  = (float) (mWidth - mGapLeft - mGapRight) / (float) (ValuesCount-1);
		float pointStepY  = (float) (mHeight - mGapTop - mGapBottom) / (float) (maxY - minY );
		float drawOffsetX = (float) mGapLeft;
		float drawOffsetY = (float)( mHeight - mGapBottom);
		//--------------------------------------------------------------------------
		ChartItem = mLineChartArray.get(0);
		OldX      = drawOffsetX;
		OldY      = drawOffsetY - pointStepY * (float) (ChartItem.Connection - minY);
		Path mPath = new Path();
		for (int k = 0; k<ValuesCount; k++){
			ChartItem = mLineChartArray.get(k);
			NewX      = drawOffsetX + ( pointStepX * (float) k );
			NewY      = drawOffsetY - ( pointStepY * (float) ( ChartItem.Connection - minY) );
			if (mFillGraph == false){
				mCanvas.drawLine(OldX, OldY, NewX, NewY, mLinePaint);
			} else {
				mPath.rewind();
				mPath.moveTo(OldX, OldY);
				mPath.lineTo(NewX, NewY);
				mPath.lineTo(NewX, drawOffsetY);
				mPath.lineTo(OldX, drawOffsetY);
				mPath.close();
				mCanvas.drawPath(mPath, mLinePaint);
			}
			OldX = NewX;
			OldY = NewY;
		}
		//--------------------------------------------------------------------------
		// Average Line
		//--------------------------------------------------------------------------
		if (mAverageLine == true){
			mAveragePaint.setColor(0xffff0000);
			mAveragePaint.setStyle(Paint.Style.FILL);
			mAveragePaint.setAntiAlias(true);
			mAveragePaint.setStrokeWidth(1.5f);
			mAveragePaint.setPathEffect( new DashPathEffect(new float[] {5, 5}, 1) );
			//--------------------------------------------------------------------------
			mAverageTxtPaint.setStyle(Paint.Style.FILL);
			mAverageTxtPaint.setTextAlign(Paint.Align.LEFT);
			mAverageTxtPaint.setColor(0xffff0000);
			mAverageTxtPaint.setTextSize(10);
			//--------------------------------------------------------------------------
			DecimalFormat FloatFormatter = new DecimalFormat("0.##");
			String StrAverage = "" + FloatFormatter.format (graphAverage);
			mAverageTxtPaint.getTextBounds(StrAverage, 0, StrAverage.length(), TextRect);
			NewX = (float)( mWidth - mGapRight - TextRect.right) - 3.0f;
			NewY = (float)( mGapTop - TextRect.top) + 3.0f;
			mCanvas.drawText(StrAverage, NewX, NewY, mAverageTxtPaint);
			NewY = drawOffsetY - ( pointStepY * (float) ( graphAverage - minY) );
			mCanvas.drawLine(mGapLeft, NewY, mWidth - mGapRight, NewY, mAveragePaint);
		}
		//--------------------------------------------------------------------------
		// Title
		//--------------------------------------------------------------------------
		ChartItem    = mLineChartArray.get(0);
		String Title =  mLineChartArray.get(0).Date  + " ... " + mLineChartArray.get(ValuesCount-1).Date;
		mTitlePaint.getTextBounds(Title, 0, Title.length(), TextRect);
		mCanvas.drawText(Title, (mWidth - TextRect.right)/2, 10, mTitlePaint);
		//--------------------------------------------------------------------------
		Title = mUrl;
		mTitlePaint.getTextBounds(Title, 0, Title.length(), TextRect);
		mCanvas.drawText(Title, (mWidth - TextRect.right)/2, 20, mTitlePaint);
	}
	//--------------------------------------------------------------------------------------
	public void setGeometry(int width, int height, int GapLeft, int GapRight, int GapTop, int GapBottom) {
		mWidth     = width;
		mHeight    = height;
		mGapLeft   = GapLeft;
		mGapRight  = GapRight;
		mGapTop    = GapTop;
		mGapBottom = GapBottom;
	}
	//--------------------------------------------------------------------------------------
	public void setSkinParams(int bgColor, int gridColor, int lineColor, int textColor, boolean FillGraph, boolean AverageLine, boolean ZoomChart) {
		mBgColor     = bgColor;
		mGridColor   = gridColor;
		mLineColor   = lineColor;
		mTextColor   = textColor;
		mFillGraph   = FillGraph;
		mAverageLine = AverageLine;
		mZoomChart   = ZoomChart;
	}
	//--------------------------------------------------------------------------------------
	public void setData( List<LineChartItem>  ChartArray, String  Url) {
		mLineChartArray = ChartArray;
		mUrl = Url;
		isReadyToDraw = true;
	}
}

As always, you can download all files HERE.

MswBMPCodec.as Class file content :

package msw.asBitmap
{
	import flash.display.BitmapData;
	import flash.filesystem.File;
	import flash.filesystem.FileMode;
	import flash.filesystem.FileStream;
	import flash.utils.ByteArray;
	import flash.utils.Endian;

	public class MswBMPCodec
	{
		private const MASK     : int = 0xFF;
		public  var   FileData : Object;

		//****************************************************
		// Class Constructor !!!
		//****************************************************
		public function MswBMPCodec()
		{
			FileData = new Object();
			super();
		}
		//****************************************************
		// Function Read BMP file with path
		//****************************************************
		public function ReadBMPWithFilename(filename : String ) : BitmapData {
			var BmpFile : File = new File(filename);
			return ReadBMP( BmpFile );
		}
		//****************************************************
		// Function Read BMP file with File
		//****************************************************
		public function ReadBMP(BmpFile : File) : BitmapData {
			var BufferedImage : BitmapData;
			try{
			 	var I   : int;
				var J   : int;
				var K   : int
			 	var Blue  : int = 0;
				var Red   : int = 0;
				var Green : int = 0;
				var Alpha : int = 0;
			 	var Bytes     : ByteArray  = new ByteArray();
			 	Bytes.endian = Endian.LITTLE_ENDIAN;

			 	var BmpStream : FileStream = new FileStream();
				BmpStream.open(BmpFile, FileMode.READ);
				BmpStream.position = 0;
				BmpStream.readBytes(Bytes, 0, BmpFile.size );
				BmpStream.close();
				//------------------------------------------------------
			 	// La signature (sur 2 octets), indiquant qu'il s'agit
				// d'un fichier BMP à l'aide des deux caractères.
				// BM,indique qu'il s'agit d'un Bitmap Windows.
				// BA indique qu'il s'agit d'un Bitmap OS/2.
				// CI indique qu'il s'agit d'une icone couleur OS/2.
				// CP indique qu'il s'agit d'un pointeur de couleur OS/2.
				// IC indique qu'il s'agit d'une icone OS/2.
				// PT indique qu'il s'agit d'un pointeur OS/2.
				//------------------------------------------------------
			 	FileData.signature  = Bytes.readShort();
			 	if (FileData.signature != 0x4D42){
					return null;
				}
		        	//------------------------------------------------------
			 	// La taille totale du fichier en octets (4 octets)
			 	//------------------------------------------------------
			 	FileData.size       = Bytes.readInt();
			 	//------------------------------------------------------
			 	// Un champ réservé (4 octets)
			 	//------------------------------------------------------
			 	FileData.reserved   = Bytes.readInt();
			 	//------------------------------------------------------
			 	// L'offset de l'image (4 octets), c'est-à-dire
				// l'adresse relative du début des informations concernant
				// l'image par rapport au début du fichier
				//------------------------------------------------------
			 	FileData.offset = Bytes.readInt();
			 	//------------------------------------------------------
			 	// La taille de l'entête de l'image en octets (4 octets).
			 	// Les valeurs hexadécimales suivantes sont possibles
				// suivant le type de format BMP :
          			// 28 pour Windows 3.1x, 95, NT, ...
          			// 0C pour OS/2 1.x
          			// F0 pour OS/2 2.x
          			//------------------------------------------------------
			 	FileData.headerSize = Bytes.readInt();
			 	if (FileData.headerSize != 0x28){
		           		return null;
		        	}
		        	//------------------------------------------------------
				// La largeur de l'image (4 octets), c'est-à-dire le
				// nombre de pixels horizontalement
				//------------------------------------------------------
			 	FileData.width      = Bytes.readInt();
			 	//------------------------------------------------------
			 	//La hauteur de l'image (4 octets), c'est-à-dire le
				// nombre de pixels verticalement
			 	//------------------------------------------------------
			 	FileData.height     = Bytes.readInt();
				//------------------------------------------------------
				// Le nombre de plans (2 octets). Cette valeur vaut
				// toujours 1
				//------------------------------------------------------
				FileData.mapCount   = Bytes.readShort();
				//------------------------------------------------------
				// La profondeur de codage de la couleur (2 octets),
				// c'est-à-dire le nombre de bits utilisés pour coder la
				// couleur. Cette valeur peut-être égale à 1, 4, 8, 16,
				// 24 ou 32
				//------------------------------------------------------
				FileData.byteDepth = Bytes.readShort();
		        	if (FileData.byteDepth < 24){
		        		return null;
		        	}
		        	//------------------------------------------------------
				// La méthode de compression (4 octets). Cette valeur
				// vaut 0 lorsque l'image n'est pas compressée,
				// ou bien 1, 2, 3 ou 4 suivant le type de compression
				// utilisé  :
				// 0 pas de compression
          			// 1 pour un codage RLE de 8 bits par pixel
          			// 2 pour un codage RLE de 4 bits par pixel
          			// 3 pour un codage bitfields, signifiant que la couleur
				// est codé par un triple masque représenté par la palette
          			// 3 pour un codage Huffman, signifiant 1-bit-per-pixel
				// modified Huffman compression
          			// 4 pour un codage RLE de 24 bits par pixel
          			//------------------------------------------------------
				FileData.compression = Bytes.readInt();
				//------------------------------------------------------
				// La taille totale de l'image en octets (4 octets).
				//------------------------------------------------------
				FileData.imageSize = Bytes.readInt();
				//------------------------------------------------------
				// La résolution horizontale (4 octets), c'est-à-dire
				// le nombre de pixels par mètre horizontalement
				//------------------------------------------------------
				FileData.horizontalResolution = Bytes.readInt();
				//------------------------------------------------------
    				// La résolution verticale (4 octets), c'est-à-dire
				// le nombre de pixels par mètre verticalement
    				//------------------------------------------------------
    				FileData.verticalResolution  = Bytes.readInt();
    				//------------------------------------------------------
    				// Le nombre de couleurs de la palette (4 octets)
    				//------------------------------------------------------
    				FileData.colorPaletteCount = Bytes.readInt();
    				//------------------------------------------------------
    				// Le nombre de couleurs importantes de la palette
				// (4 octets). Ce champ peut être égal à 0 lorsque
				// chaque couleur a son importance.
    				//------------------------------------------------------
    				FileData.significantColorsCount = Bytes.readInt();
    				if (FileData.colorPaletteCount > 0){
    					var ColorArray : Array = new Array();
    					for(var loop : int = 1;  loop = 4*FileData.colorPaletteCount; loop ++){
    						Blue  = Bytes.readUnsignedByte();
						Green = Bytes.readUnsignedByte();
						Red   = Bytes.readUnsignedByte();
						Alpha = Bytes.readUnsignedByte();
					 	ColorArray.push(256*256*Red + 256*Green+Blue);
    					}
    					FileData.paletteColor = ColorArray;
    				}
    				//------------------------------------------------------
    				// Lecture des Données !!!
    				//------------------------------------------------------
    				Bytes.position = FileData.offset;
    				switch(FileData.byteDepth) {
					case 24:
						BufferedImage = new BitmapData(FileData.width, FileData.height, false, 0x000000);
					    	break;
					case 32:
			 			BufferedImage = new BitmapData(FileData.width, FileData.height, true, 0x00000000);
			 			break;
    				}
				var JunkCount : int = (FileData.width * 3) % 4;
			 	switch(FileData.byteDepth) {
					case 24:
						for(J = FileData.height - 1; J >= 0; J--){
					 		for(I = 0; I < FileData.width ; I++){
					 			Blue  = Bytes.readUnsignedByte();
								Green = Bytes.readUnsignedByte();
								Red   = Bytes.readUnsignedByte();
					 			BufferedImage.setPixel( I, J, 256*256*Red + 256*Green + Blue);
					 		}
					 		for(K = 0; K < JunkCount; K++){
					 			Bytes.readUnsignedByte();
					 		}
						}
					    	break;

					case 32:
						for(J = FileData.height - 1; J >= 0; J--){
					 		for(I = 0; I < FileData.width; I++){
					 			Blue  = Bytes.readUnsignedByte();
								Green = Bytes.readUnsignedByte();
								Red   = Bytes.readUnsignedByte();
								Alpha = Bytes.readUnsignedByte();
					 			BufferedImage.setPixel32( I, J, 256*256*256*Alpha + 256*256*Red + 256*Green + Blue);
					 		}
						}
						break;
				}
			} catch(e:Error){
			} finally {}

			return BufferedImage;
		}
		//****************************************************
		// Function Write BMP file with path
		//****************************************************
		public function writeBMPWithFilename(BufferedImage : BitmapData, filename : String ) : Boolean {
			var BmpFile : File = new File(filename);
			return writeBMP(BufferedImage, BmpFile);
		}
		//****************************************************
		// Function Write BMP file with File
		//****************************************************
		public function writeBMP(BufferedImage : BitmapData, BmpFile : File) : Boolean {
			try{
		 		var Result : Boolean   = true;
		 		var Width  : int       = BufferedImage.width;
				var Height : int       = BufferedImage.height;
				var Bytes  : ByteArray = new ByteArray();
			 	Bytes.endian = Endian.LITTLE_ENDIAN;
			 	//------------------------------------------------------
			 	// La signature (sur 2 octets), indiquant qu'il s'agit
				// d'un fichier BMP à l'aide des deux caractères.
				// BM,indique qu'il s'agit d'un Bitmap Windows.
				//------------------------------------------------------
		 		Bytes.writeShort(0x424D);
		 		//------------------------------------------------------
		 		// La taille totale du fichier en octets (4 octets)
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(Width*Height*4 + 0x36);
		 		//------------------------------------------------------
		 		// Un champ réservé (sur 4 octets)
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x00);
		 		//------------------------------------------------------
		 		// L'offset de l'image (4 octets), c'est-à-dire
				// l'adresse relative du début des informations concernant
				// l'image par rapport au début du fichier
				//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x36);
		 		//------------------------------------------------------
		 		// La taille de l'entête de l'image en octets (4 octets).
			 	// Les valeurs hexadécimales suivantes sont possibles
				// suivant le type de format BMP :
				// 28 pour Windows 3.1x, 95, NT, ...
				// 0C pour OS/2 1.x
				// F0 pour OS/2 2.x
				//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x28);
		 		//------------------------------------------------------
		 		// La largeur de l'image (4 octets), c'est-à-dire
				// le nombre de pixels horizontalement
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(Width);
		 		//------------------------------------------------------
		 		//La hauteur de l'image (4 octets), c'est-à-dire
				// le nombre de pixels verticalement
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(Height);
		 		//------------------------------------------------------
		 		// Le nombre de plans (2 octets). Cette valeur vaut
				// toujours 1
		 		//------------------------------------------------------
		 		Bytes.writeShort(0x01);
				//------------------------------------------------------
		 		// La profondeur de codage de la couleur(2 octets),
				// c'est-à-dire le nombre de bits utilisés pour coder
				// la couleur. Cette valeur peut-être égale à 1, 4, 8,
				// 16, 24 ou 32
				//------------------------------------------------------
		 		Bytes.writeShort(0x20);
		 		//------------------------------------------------------
		 		// La méthode de compression (4 octets). Cette valeur
				// vaut 0 lorsque l'image n'est pas compressée,
				// ou bien 1, 2 ou 3 suivant le type de compression
				// utilisé  :
				// 0 pas de compression
				// 1 pour un codage RLE de 8 bits par pixel
				// 2 pour un codage RLE de 4 bits par pixel
				// 3 pour un codage bitfields, signifiant que la couleur
				// est codé par un triple masque représenté par la palette
				// 3 pour un codage Huffman, signifiant 1-bit-per-pixel
				// modified Huffman compression
				// 4 pour un codage RLE de 24 bits par pixel
				//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x00);
		 		//------------------------------------------------------
		 		// La taille totale de l'image en octets (4 octets).
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(Width*Height*4);
		 		//------------------------------------------------------
		 		// La résolution horizontale (4 octets), c'est-à-dire
				// le nombre de pixels par mètre horizontalement
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x0EC4);
		 		//------------------------------------------------------
		 		// La résolution verticale (4 octets), c'est-à-dire
				// le nombre de pixels par mètre verticalement
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x0EC4);
		 		//------------------------------------------------------
		 		// Le nombre de couleurs de la palette (4 octets)
		 		//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x00);
		 		//------------------------------------------------------
		 		// Le nombre de couleurs importantes de la palette
				// (4 octets). Ce champ peut être égal à 0 lorsque
				// chaque couleur a son importance.
				//------------------------------------------------------
		 		Bytes.writeUnsignedInt(0x00);
		 		//------------------------------------------------------
		 		//Ecriture du corps du fichier BMP
		 		//------------------------------------------------------
		 		for (var Y : int = Height - 1; Y >= 0; Y--) {
		 			for (var X : int = 0; X < Width; X++) {
		 				Bytes.writeUnsignedInt( BufferedImage.getPixel32(X,Y) );
		 			}
		 		}
		 		//------------------------------------------------------
		 		// Enregistrement du fichier
		 		//------------------------------------------------------
		 		var BmpStream : FileStream = new FileStream();
				BmpStream.open(BmpFile, FileMode.WRITE);
				BmpStream.position = 0;
				BmpStream.writeBytes(Bytes);
			 	BmpStream.close();
				return true;
		 	} catch(e:Error){
		 		return false;
		 	}
		 	return true;
		}
	}
}

Use : (Functions written on the fly and not tested!)

import msw.asBitmap.MswBMPCodec;
....
public function ConvertBmpToJpg(BmpFile: File, JpgFile : File) : void {
	var BmpEncoder : MswBMPCodec = new MswBMPCodec();
	var BmpBitmapData : BitmapData = BmpEncoder.ReadBMP(BmpFile);
	var jpg : JPEGEncoder = new JPEGEncoder(100);
	var ResByteArray  : ByteArray   = jpg.encode(BmpBitmapData);
	var fileStream : FileStream = new FileStream();
	fileStream.open(JpgFile, FileMode.WRITE);
	fileStream.writeBytes(ResByteArray);
	fileStream.close();
}

public function ConvertJpgToBmp(BmpFile: File, JpgFile : File) : void {
	private function ImageLoadHandler(event : Event) : void {
		event .target.removeEventListener(Event.COMPLETE, ImageLoadHandler)
		var BmpEncoder : MswBMPCodec = new MswBMPCodec();
		BmpEncoder.writeBMP(event .target.content.bitmapData, BmpFile);
	}
	var loader : Loader = new Loader();
	loader.contentLoaderInfo.addEventListener(Event.COMPLETE, ImageLoadHandler, false, 0, true)
	loader.load( new URLRequest(JpgFile.url) );
}

You can download filesHERE.