http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/cda78507/flex-installer/installer/src/InstallApacheFlex.mxml ---------------------------------------------------------------------- diff --git a/flex-installer/installer/src/InstallApacheFlex.mxml b/flex-installer/installer/src/InstallApacheFlex.mxml new file mode 100644 index 0000000..055e44f --- /dev/null +++ b/flex-installer/installer/src/InstallApacheFlex.mxml @@ -0,0 +1,4019 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- + +Licensed to the Apache Software Foundation (ASF) under one or more +contributor license agreements. See the NOTICE file distributed with +this work for additional information regarding copyright ownership. +The ASF licenses this file to You under the Apache License, Version 2.0 +(the "License"); you may not use this file except in compliance with +the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +--> + + +<!-- + +This app should be used to create an Apache Flex SDK that has the +directory structure that an IDE expects. + +The Adobe AIR SDK and the Adobe Flash Player playerglobal.swc are integrated +into the directory structure. The paths in the framework configuration files are +modified to reflect this. The AIR_HOME and PLAYERGLOBAL_HOME environment +variables are not required because the locations of these pieces are known. + +--> + + +<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"; + xmlns:s="library://ns.adobe.com/flex/spark" + width="800" height="700" maxWidth="800" maxHeight="700" minWidth="800" minHeight="700" + backgroundColor="0xDDDDDD" + preinitialize="getInvoke()" + applicationComplete="handleApplicationComplete(event)" showStatusBar="false" + skinClass="ws.tink.spark.skins.controls.InstallApacheFlexSkin" + xmlns:controls="ws.tink.spark.controls.*" + xmlns:controls1="org.apache.flex.packageflexsdk.view.controls.*" + xmlns:components="org.apache.flex.packageflexsdk.view.components.*" + xmlns:controls2="org.apache.flex.utilities.common.controls.*"> + + <fx:Style source="assets/styles/ApacheFlexToolsStyle.css"/> + <fx:Style source="assets/styles/InstallApacheFlexStyle.css"/> + + <fx:Declarations> + <fx:Component className="CacheDialog" > + <s:TitleWindow title="Download Cache Configuration" width="400" height="130" + backgroundColor="0xDDDDDD" close="closeUp()"> + <fx:Script> + <![CDATA[ + import mx.managers.PopUpManager; + + private function browseFolders():void + { + var file:File; + if (folder.text.length > 0) + file = File.applicationStorageDirectory.resolvePath(folder.text); + else + file = File.applicationStorageDirectory; + file.browseForDirectory("Download Cache Folder"); + file.addEventListener(Event.SELECT, folderSelected); + } + + private function folderSelected(event:Event):void + { + folder.text = event.target.nativePath; + } + + private function closeUp():void + { + PopUpManager.removePopUp(this); + } + + private function updateCache():void + { + dispatchEvent(new Event(Event.COMPLETE)); + closeUp(); + } + ]]> + </fx:Script> + <s:VGroup left="10" top="10" right="10"> + <s:CheckBox id="cb" label="Cache Downloaded Files" /> + <s:HGroup width="100%" verticalAlign="baseline"> + <s:Label text="Cache Folder: " /> + <s:TextInput id="folder" width="100%" enabled="{cb.selected}"/> + <s:Button label="Browse..." click="browseFolders()" styleName="genericBtnStyle" enabled="{cb.selected}"/> + </s:HGroup> + <s:HGroup horizontalAlign="center" width="100%" > + <s:Button label="OK" click="updateCache()" enabled="{cb.selected == false || folder.text.length > 0}" styleName="genericBtnStyle" /> + <s:Button label="Cancel" click="closeUp()" styleName="genericBtnStyle" /> + </s:HGroup> + </s:VGroup> + </s:TitleWindow> + </fx:Component> + </fx:Declarations> + <fx:Script><![CDATA[ + import flash.globalization.LocaleID; + import flash.globalization.StringTools; + + import mx.collections.ArrayCollection; + import mx.core.IFlexDisplayObject; + import mx.events.FlexEvent; + import mx.events.PropertyChangeEvent; + import mx.managers.CursorManager; + import mx.managers.PopUpManager; + import mx.resources.ResourceBundle; + import mx.rpc.events.FaultEvent; + import mx.rpc.events.ResultEvent; + import mx.rpc.http.HTTPService; + import mx.utils.StringUtil; + + import org.apache.flex.packageflexsdk.util.ApacheURLLoader; + + import spark.events.IndexChangeEvent; + import spark.events.TextOperationEvent; + + // This force-links all of the ant task handlers into the Installer. + // The Installer doesn't use most of them directly but some script + // it runs might. + import AntClasses; + + AntClasses; + + import org.apache.flex.ant.Ant; + import org.apache.flex.ant.tags.Checksum; + import org.apache.flex.ant.tags.Copy; + import org.apache.flex.ant.tags.Get; + import org.apache.flex.packageflexsdk.model.InstallerComponentVO; + import org.apache.flex.packageflexsdk.model.OS; + import org.apache.flex.packageflexsdk.resource.ViewResourceConstants; + import org.apache.flex.packageflexsdk.util.CalcButtonWidth; + import org.apache.flex.packageflexsdk.util.MD5CompareUtil; + import org.apache.flex.packageflexsdk.view.UpdaterDialog; + import org.apache.flex.packageflexsdk.view.components.AdobeLicense; + import org.apache.flex.packageflexsdk.view.components.ConsoleWindow; + import org.apache.flex.packageflexsdk.view.components.MPLLicense; + import org.apache.flex.packageflexsdk.view.events.InstallItemSelectionEvent; + import org.apache.flex.utilities.common.Constants; + import org.apache.flex.utilities.common.MirrorURLUtil; + import org.apache.flex.utilities.common.interfaces.ILog; + import org.apache.flex.utilities.common.vo.LogMessagesVO; + import org.as3commons.zip.Zip; + import org.as3commons.zip.ZipEvent; + import org.as3commons.zip.ZipFile; + import org.osmf.utils.OSMFStrings; + + import ws.tink.spark.controls.StepItem; + import ws.tink.spark.skins.controls.InstallApacheFlexSkin; + + // embed us strings so we can always have them if we can't get to the locale files + [Embed(source="properties/en_US.properties", mimeType="application/octet-stream")] + private var en_US_Properties:Class; + + private var cleanedUp:Boolean; + + private var _mirrorURLCGI:String; + private var _useMirror:Boolean = true; + private var _latestVersion:String; + private var loggedVersion:Boolean; + private var logFile:String; + private var debugMode:Boolean = false; + private var logProgressEvents:Boolean = false; + private var showDevBuilds:Boolean = false; + private var usingDownloadCache:Boolean; + private var downloadCacheFolder:String; + private var userDefaultLanguage:String; + private var firstTime:Boolean = true; + private var legacy:Boolean = true; + private var nocache:Boolean = true; + private var wasAborted:Boolean; + private var newSDKSelected:Boolean = true; + + public var installerAppPath:String; + public var installerAppFileName:String; + + // loader needs to be in instance var otherwise it can get GC'd. + // We only load one thing at a time, so we can all share this + // var + private var loader:ApacheURLLoader; + + /** + * Utility Singleton Instances + */ + private var _md5CompareUtil:MD5CompareUtil = MD5CompareUtil.instance; + private var _mirrorURLUtil:MirrorURLUtil = MirrorURLUtil.instance; + + /** + * Apache Flex binary distribution + * + * Values stored in sdk-installer-config.xml edit file to change + * + */ + private var APACHE_FLEX_BIN_DISTRO_PATH:String; + private var APACHE_FLEX_BIN_DISTRO_FILE:String; + private var APACHE_FLEX_BIN_INSTALLER_FILE:String; + private var APACHE_FLEX_BIN_DISTRO_FILE_SHORT:String; + private var APACHE_FLEX_BIN_DISTRO_URL:String; + private var APACHE_FLEX_BIN_INSTALLER_URL:String; + [Bindable] + private var APACHE_FLEX_BIN_DISTRO_VERSION:String = ""; + [Bindable] + private var APACHE_FLEX_BIN_DISTRO_VERSION_DISPLAY:String = ""; + + /** + * Adobe AIR SDK + * + * Values stored in sdk-installer-config.xml edit file to change + * + */ + [Bindable] + private var AIR_VERSIONS:ArrayCollection = new ArrayCollection(); + private var AIR_VERSION:String = "14.0"; + private var ADOBE_AIR_SDK_WIN_FILE:String; + private var ADOBE_AIR_SDK_WIN_URL:String; + private var ADOBE_AIR_SDK_MAC_FILE:String; + private var ADOBE_AIR_SDK_MAC_URL:String; + private var ADOBE_AIR_SDK_LINUX_FILE:String; + private var ADOBE_AIR_SDK_LINUX_URL:String; + + /** + * Adobe Flash Player + * + * Values stored in sdk-installer-config.xml edit file to change + * + */ + [Bindable] + private var FLASH_PLAYER_VERSIONS:ArrayCollection = new ArrayCollection(); + private var FLASH_PLAYER_VERSION:String = "11.1"; + private var FLASH_PLAYER_SWF_VERSION:String = "14"; + private var ADOBE_FB_GLOBALPLAYER_SWC_FILE:String; + private var ADOBE_FB_GLOBALPLAYER_SWC_URL:String; + + /** + * Apache Flex + * + * Values stored in sdk-installer-config.xml edit file to change + * + */ + [Bindable] + private var FLEX_VERSIONS:ArrayCollection = new ArrayCollection(); + + /** + * + * SwfObject + * + */ + private var SWF_OBJECT_FILE:String; + private var SWF_OBJECT_URL:String; + + /** + * Optional installs + * + */ + private var OSMF_SWC_FILE:String; + private var OSMF_SWC_URL:String; + private var OSMF_SWF_FILE:String = "osmf.swf"; + + private var BLAZEDS_FILE:String; + private var BLAZEDS_URL:String; + + private var AFE_FILE:String; + private var AFE_URL:String; + private var AGLJ40_FILE:String; + private var AGLJ40_URL:String; + private var FLEX_FONTKIT_FILE:String; + private var FLEX_FONTKIT_URL:String; + private var RIDEAU_FILE:String; + private var RIDEAU_URL:String; + + [Bindable] + private var _flexHome:String; + private var _flexTemp:String; + private var _flexHomeDir:File; + private var _flexTempDir:File; + private var _apacheFlexSDKCompressedFile:File; + private var _adobeAIRSDKZipFile:File; + private var _fbGlobalPlayerDir:File; + private var _fbGlobalPlayerFile:File; + private var _blazeDSJarFile:File; + private var _afeJarFile:File; + private var _aglj40JarFile:File; + private var _flexFontKitJarFile:File; + private var _rideauJarFile:File; + private var _osmfSWCFile:File; + private var _osmfSWFFile:File; + + private var _os:OS = new OS(); + private var _loader:ApacheURLLoader; + private var _process:NativeProcess; + private var _previousDisplayedPercent:int = 0; + private var _fileUnzipErrorFunction:Function; + private var _numOptionalComponents:int = 4; + private var _numOptionalComponentsPermissions:int = 0; + private var _useOSMF2:Boolean = true; + + private var languageOverride:String; + private var configOverride:String = ""; + private var stepsOverride:String = ""; + private var installOverride:String = ""; + + private var overlaying:Boolean; + private var usingXML:Object; + private var additionalProps:Object = {}; + private var licensePropertyMap:Object = {}; + private var progressLabels:XML; + private var installStepsData:XMLList; + private var compList:XMLList; + private var stepIDs:Vector.<String> = new Vector.<String>(); + private var stepLabels:Vector.<String> = new Vector.<String>(); + private var currentStep:int = 0; + + private var lastLicenseItemSelected:int = 0; + + private var customMenuItem1:ContextMenuItem = new ContextMenuItem("Show Dev Builds"); + private var customMenuItem2:ContextMenuItem = new ContextMenuItem("Configure Download Cache..."); + private var customMenuItem3:ContextMenuItem = new ContextMenuItem("Enable Verbose Logging"); + private var customMenuItem4:ContextMenuItem = new ContextMenuItem("Enable Progress Logging"); + + [Bindable] + private var _viewResourceConstants:ViewResourceConstants; + [Bindable] + private var supportedLanguages:ArrayCollection = new ArrayCollection(); + [Bindable] + private var _installationSteps:ArrayCollection = new ArrayCollection(); + [Bindable] + private var _installerComponentsDataProvider:ArrayCollection = new ArrayCollection(); + [Bindable] + private var _currentLicenseURL:String; + [Bindable] + private var _currentLicenseLabel:String; + [Bindable] + public var _messages:ArrayCollection = new ArrayCollection(); + + private var _lastTag:String; + private var _lastPublicMessage:String; + public function set lastPublicMessage(s:String):void + { + var tag:String; + var c:int; + + c = s.indexOf("["); + if (c != -1) + { + var c2:int = s.indexOf("] "); + if (c2 != -1) + { + tag = s.substring(c + 1, c2); + s = s.substr(c2 + 2); + } + } + if (tag && tag == _lastTag && tag == "get") + { + _lastPublicMessage += "\n" + s; + } + else + { + _lastPublicMessage = s; + } + _lastTag = tag; + dispatchEvent(new Event("messageChanged")); + } + + [Bindable("messageChanged")] + public function get lastFilteredPublicMessage():String + { + return _lastPublicMessage; + } + + private function getInvoke():void + { + var nativeApplication:NativeApplication = NativeApplication.nativeApplication; + nativeApplication.addEventListener(InvokeEvent.INVOKE, parseArgs); + } + + [Bindable] + private var _standardButtonWidth:Number = 88; + + public function setButtonWidths():void + { + var calc:CalcButtonWidth = new CalcButtonWidth(hiddenButton); + + calc.buttonWidth(installLogBtn); + calc.buttonWidth(openApacheFlexFolderBtn); + + _standardButtonWidth = calc.maxButtonWidth([installBtn, browseBtn, closeBtn, nextBtn, firstStepBackBtn, secondStepBackBtn]); + } + + private function parseArgs(event:InvokeEvent):void + { + for each (var s:String in event.arguments) + { + if (s.indexOf("-language=") == 0) + { + languageOverride = s.substring(10); + } + if (s.indexOf("-config=") == 0) + { + configOverride = s.substring(8); + } + if (s.indexOf("-install=") == 0) + { + installOverride = s.substring(9); + } + if (s.indexOf("-steps=") == 0) + { + stepsOverride = s.substring(7); + } + if (s.indexOf("-debug") == 0) + { + debugMode = true; + } + if (s.indexOf("-log=") == 0) + { + debugMode = true; + logFile = s.substring(5); + } + } + var so:SharedObject = SharedObject.getLocal("InstallApacheFlex"); + usingDownloadCache = so.data.usingDownloadCache; + downloadCacheFolder = so.data.downloadCacheFolder; + userDefaultLanguage = so.data.userDefaultLanguage; + } + + protected function handleApplicationComplete(event:FlexEvent):void + { + CursorManager.setBusyCursor(); + loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler); + addEventListener(Event.CLOSING, closeApplication); + updateWindow(); + var hasInternet:Boolean = false; + var networkAdapters:Vector.<NetworkInterface> = NetworkInfo.networkInfo.findInterfaces(); + for each (var networkAdapter:NetworkInterface in networkAdapters) + { + if (networkAdapter.active) + { + hasInternet = true; + break; + } + } + if (hasInternet) + { + loadXML(); + } + logVersion(); + if (!hasInternet) + { + log("Internet connection unavailable"); + abortInstallation("Internet connection unavailable."); + } + } + + private function uncaughtErrorHandler(event:UncaughtErrorEvent):void + { + if (currentStep > 0) + { + updateActivityStep(stepLabels[currentStep - 1], StepItem.ERROR); + } + if (event.error is Error) + { + var error:Error = event.error as Error; + log(error.message); + log(error.getStackTrace(), -1, false); + abortInstallation(error.message + "\n" + error.getStackTrace()); + } + else if (event.error is ErrorEvent) + { + var errorEvent:ErrorEvent = event.error as ErrorEvent; + log(errorEvent.text); + abortInstallation(errorEvent.text); + } + else + { + // a non-Error, non-ErrorEvent type was thrown and uncaught + log(event.toString()); + abortInstallation(event.toString()); + } + } + + /** + * Define on ResourceManager all keys for translation. + * If some key is not present on any other language selected by user, the default value will be displayed + * on the screen + */ + private function defineResourceManagerDefaultLanguage():void + { + selectDefaultLanguage(); + } + + private function getIndexOfEnUS():int + { + for (var i:int = 0; i < _langSelect.dataProvider.length; i++) + { + if (_langSelect.dataProvider.getItemAt(i).data == "en_US") + { + return i; + } + } + return -1; + } + + private function updateWindowTitle():void + { + if (_viewResourceConstants) + { + this.nativeWindow.title = StringUtil.substitute(_viewResourceConstants.INFO_WINDOW_TITLE, [APACHE_FLEX_BIN_DISTRO_VERSION_DISPLAY]); + } + } + + protected function selectDefaultLanguageInEmergency():void + { + loadLanguage("en_US", loadUSInEmergencyComplete); + } + + private function loadUSInEmergencyComplete():void + { + _viewResourceConstants = ViewResourceConstants.instance; + _viewResourceConstants.update(); + } + + protected function selectDefaultLanguage():void + { + loadLanguage("en_US", loadUSComplete); + } + + private function loadUSComplete():void + { + var userLocale:String; + + if (userDefaultLanguage) + { + userLocale = userDefaultLanguage; + } + else + { + userLocale = new StringTools(LocaleID.DEFAULT).actualLocaleIDName.replace("-", "_"); + } + + if (languageOverride) + { + userLocale = languageOverride; + } + + loadDefaultLanguage(userLocale); + } + + private function loadDefaultLanguage(userLocale:String):void + { + loadLanguage(userLocale, defaultLanguageLoaded); + } + + private var languageURL:String; + private var languageID:String; + + private function loadLanguage(userLocale:String, completeFunction:Function):void + { + if (languageURL && loader) // busy loading another language + { + loader.close(); + } + + if (userLocale == "en_US") + { + var ba:ByteArray = new en_US_Properties() as ByteArray; + var data:String = ba.readUTFBytes(ba.bytesAvailable); + installLanguage(userLocale, data); + completeFunction(); + return; + } + var n:int = supportedLanguages.length; + for (var i:int = 0; i < n; i++) + { + if (supportedLanguages[i].data == userLocale) + { + languageID = userLocale; + languageURL = supportedLanguages[i].path; + var url:URLRequest = new URLRequest(languageURL); + loader = new ApacheURLLoader(); + loader.dataFormat = URLLoaderDataFormat.TEXT; + loader.addEventListener(IOErrorEvent.IO_ERROR, languageLoadErrorHandler); + loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, languageLoadErrorHandler); + loader.addEventListener(Event.COMPLETE, function (e:Event):void + { + languageURL = null; + installLanguage(userLocale, loader.data); + completeFunction(); + }); + loader.load(url); + return; + } + } + completeFunction(); + } + + private function installLanguage(userLocale:String, data:String):void + { + var resource:ResourceBundle = new ResourceBundle(userLocale, ViewResourceConstants.BUNDLE_NAME); + var variables:Array; + if (data.indexOf("\r\n") != -1) + { + variables = data.split("\r\n"); + } + else + { + variables = data.split("\n"); + } + for each (var p:String in variables) + { + if (p.charAt(0) == "#") + { + continue; + } + + var c:int = p.indexOf("="); + if (c != -1) + { + var key:String = p.substr(0, c); + var value:String = p.substr(c + 1); + while (value.indexOf("\\n") != -1) + { + value = value.replace("\\n", "\n"); + } + resource.content[key] = value; + } + } + + resourceManager.addResourceBundle(resource); + } + + private function languageLoadErrorHandler(event:Event):void + { + log("Unable to load language file " + languageURL); + log(event.toString()); + abortInstallation("Unable to load language file " + languageURL); + } + + private function defaultLanguageLoaded():void + { + resourceManager.localeChain = [ViewResourceConstants.DEFAULT_LANGUAGE]; + + var userLocale:String; + + if (userDefaultLanguage) + { + userLocale = userDefaultLanguage; + } + else + { + userLocale = new StringTools(LocaleID.DEFAULT).actualLocaleIDName.replace("-", "_"); + } + + if (languageOverride) + { + userLocale = languageOverride; + } + log("Using Locale: " + userLocale); + + var n:int = supportedLanguages.length; + for (var i:int = 0; i < n; i++) + { + if (supportedLanguages[i].data == userLocale) + { + _langSelect.selectedIndex = i; + + resourceManager.localeChain = [userLocale, "en_US"]; + + break; + } + } + _viewResourceConstants = ViewResourceConstants.instance; + + resourceManager.addEventListener(Event.CHANGE, _viewResourceConstants.update); + + _viewResourceConstants.update(); + setButtonWidths(); + directoryBtn.enabled = true; + + updateWindow(); + + _mirrorURLUtil.logMessages = new LogMessagesVO(_viewResourceConstants.FETCH_MIRROR_CGI, _viewResourceConstants.FETCH_MIRROR_CGI_DONE, + _viewResourceConstants.FETCH_MIRROR_CGI_ERROR); + + _mirrorURLUtil.getMirrorURL(Constants.APACHE_FLEX_URL + _mirrorURLCGI, getMirrorURLResultHandler); + CursorManager.removeBusyCursor(); + + checkValidOS(); + } + + protected function updateWindow():void + { + updateWindowTitle(); + + this.nativeWindow.x = Screen.mainScreen.bounds.width / 2 - this.nativeWindow.width / 2; + this.nativeWindow.y = Screen.mainScreen.bounds.height / 2 - this.nativeWindow.height / 2; + } + + protected function loadXML():void + { + var request:URLRequest; + + if (configOverride != "") + { + request = new URLRequest(configOverride); + } + else + { + request = new URLRequest(Constants.APACHE_FLEX_URL + Constants.CONFIG_XML_NAME); + //request = new URLRequest(Constants.CONFIG_XML_NAME); + } + + _loader = new ApacheURLLoader(); + + try + { + _loader.load(request); + } + catch (error:Error) + { + selectDefaultLanguageInEmergency(); + log("Unable to load " + Constants.APACHE_FLEX_URL + Constants.CONFIG_XML_NAME); + log(_viewResourceConstants.ERROR_CONFIG_XML_LOAD + error.errorID + " " + error.message); + abortInstallation("Unable to load " + Constants.APACHE_FLEX_URL + Constants.CONFIG_XML_NAME); + } + + _loader.addEventListener(HTTPStatusEvent.HTTP_RESPONSE_STATUS, xmlLoadStatus, false, 0, true); + _loader.addEventListener(IOErrorEvent.IO_ERROR, xmlError, false, 0, true); + _loader.addEventListener(Event.COMPLETE, xmlLoaded, false, 0, true); + } + + protected function xmlLoadStatus(event:HTTPStatusEvent):void + { + if (event.status >= 400) + { + log("Unable to load " + Constants.APACHE_FLEX_URL + Constants.CONFIG_XML_NAME); + log("\tServer Status: " + event.status); + } + } + + protected function xmlError(event:IOErrorEvent):void + { + selectDefaultLanguageInEmergency(); + log("Unable to load " + Constants.APACHE_FLEX_URL + Constants.CONFIG_XML_NAME); + log(_viewResourceConstants.ERROR_CONFIG_XML_LOAD + event.errorID); + abortInstallation("Unable to load " + Constants.APACHE_FLEX_URL + Constants.CONFIG_XML_NAME + " " + event.toString()); + } + + protected function xmlLoaded(event:Event):void + { + if (setXMLVariables()) + { + _langSelect.dataProvider = supportedLanguages; + _langSelect.selectedIndex = getIndexOfEnUS(); + _langSelect.enabled = true; + defineResourceManagerDefaultLanguage(); + } + } + + protected function checkValidOS():void + { + if (_os.isOther()) + { + log(_viewResourceConstants.ERROR_UNSUPPORTED_OPERATING_SYSTEM); + } + } + + private function devBuildFilterFunction(o:Object):Boolean + { + return !o.devBuild; + } + + private function debugModeHandler(event:Event):void + { + debugMode = true; + customMenuItem3.caption = "Verbose Logging Enabled"; + } + + private function debugProgressHandler(event:Event):void + { + logProgressEvents = true; + customMenuItem4.caption = "Logging Progress Events"; + } + + private function devBuildShowHandler(event:Event):void + { + var item:Object = flexVersion.selectedItem; + FLEX_VERSIONS.filterFunction = null; + FLEX_VERSIONS.refresh(); + flexVersion.selectedItem = item; + customMenuItem1.caption = "Showing Dev Builds"; + } + + private function downloadCacheHandler(event:Event):void + { + var dlg:CacheDialog = new CacheDialog(); + dlg.addEventListener(Event.COMPLETE, updateDownloadCache); + PopUpManager.addPopUp(dlg, this, true); + PopUpManager.centerPopUp(dlg); + dlg.cb.selected = usingDownloadCache; + dlg.folder.text = downloadCacheFolder; + } + + private function updateDownloadCache(event:Event):void + { + downloadCacheFolder = event.target.folder.text; + usingDownloadCache = event.target.cb.selected; + var so:SharedObject = SharedObject.getLocal("InstallApacheFlex"); + so.data.usingDownloadCache = usingDownloadCache; + so.data.downloadCacheFolder = downloadCacheFolder; + so.flush(); + } + + protected function setXMLVariables():Boolean + { + try + { + var data:XML = XML(_loader.data); + } + catch (e:Error) + { + log("Error parsing configuration file"); + abortInstallation("Error parsing configuration file"); + return false; + } + var keepGoing:Boolean = true; + if (firstTime) + { + firstTime = false; + + _latestVersion = data.version.latest.toString(); + + installerAppPath = data.installer.(@name == 'SDKInstallerApp')[email protected](); + installerAppFileName = data.installer.(@name == 'SDKInstallerApp')[email protected](); + + _mirrorURLCGI = data.mirror.(@name == 'MirrorURLCGI')[email protected](); + + customMenuItem1.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, devBuildShowHandler); + customMenuItem2.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, downloadCacheHandler); + customMenuItem3.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, debugModeHandler); + customMenuItem4.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, debugProgressHandler); + + var contextMenuCustomItems:Array = ContextMenu(contextMenu).customItems; + contextMenuCustomItems.push(customMenuItem1); + contextMenuCustomItems.push(customMenuItem2); + contextMenuCustomItems.push(customMenuItem3); + contextMenuCustomItems.push(customMenuItem4); + + var name:String; + var versionString:String; + var versionID:String; + + var languages:XMLList = data.languages.children(); + for each (var lang:XML in languages) + { + var item:Object = { + label: [email protected](), + data: [email protected](), + path: [email protected]() + }; + supportedLanguages.addItem(item); + } + + var airData:XMLList = data.airsdk[_os.os].versions; + var airVersionList:XMLList = airData[0].children(); + var airVersions:Array = []; + var selected:String = airData[0]["@default"].toString(); + for each (var airVersion:XML in airVersionList) + { + var displayVersion:String = [email protected](); + versionString = [email protected](); + versionID = null; + if ([email protected]() > 0) + { + versionID = [email protected](); + } + airVersions.push(versionString); + var airPath:String = airVersion.path.toString(); + var airFile:String = airVersion.file.toString(); + AIR_VERSIONS.addItem({ + label: "AIR " + displayVersion, version: versionString, versionID: versionID, + path: airPath, file: airFile + }); + } + + if (this.airVersion.selectedIndex == -1) + { + this.airVersion.selectedIndex = airVersions.indexOf(selected); + } + + var flexData:XMLList = data.products.children(); + var selectedFlexVersion:int; + for each (var productData:XML in flexData) + { + var productName:String = [email protected](); + var productPrefix:String = [email protected](); + var productVersionList:XMLList = productData.versions.children(); + var isOverlay:Boolean = [email protected]() == "true"; + var needsAIR:Boolean = [email protected]() != "false"; + var needsFlash:Boolean = [email protected]() != "false"; + var icon:String = [email protected](); + for each (var productVersion:XML in productVersionList) + { + var shortName:String = [email protected](); + var fileName:String = shortName + (_os.isWindows() ? Constants.ARCHIVE_EXTENSION_WIN : Constants.ARCHIVE_EXTENSION_MAC); + versionString = [email protected](); + var label:String = productName + " " + versionString; + var ver:String = fileName.substr(productPrefix.length).split("-")[0]; + var path:String = [email protected](); + var devBuild:Boolean = [email protected]() == "true"; + var legacy:Boolean = [email protected]() == "true"; + var nocache:Boolean = [email protected]() == "true"; + if (productVersion["@default"].length() == 1) + { + selectedFlexVersion = FLEX_VERSIONS.length; + } + FLEX_VERSIONS.addItem({ + shortName: shortName, fileName: fileName, label: label, version: ver, + path: path, overlay: isOverlay, prefix: productPrefix, legacy: legacy, nocache: nocache, + needsAIR: needsAIR, needsFlash: needsFlash, devBuild: devBuild, icon: icon + }); + } + } + + FLEX_VERSIONS.filterFunction = devBuildFilterFunction; + FLEX_VERSIONS.refresh(); + flexVersion.validateNow(); + + if (this.flexVersion.selectedIndex == -1) + { + this.flexVersion.selectedIndex = selectedFlexVersion; + } + + var selectedFlexVersionObject:Object = this.flexVersion.selectedItem; + updateFlexVersionStrings(selectedFlexVersionObject); + + if (!APACHE_FLEX_BIN_DISTRO_FILE || !APACHE_FLEX_BIN_DISTRO_PATH) + { + log(_viewResourceConstants.ERROR_INVALID_SDK_URL); + keepGoing = false; + } + + var flashData:XMLList = data.flashsdk.versions; + var flashVersionList:XMLList = flashData[0].children(); + var flashPlayerVersions:Array = []; + selected = flashData[0]["@default"].toString(); + for each (var flashVersion:XML in flashVersionList) + { + displayVersion = [email protected](); + versionString = [email protected](); + versionID = null; + if ([email protected]() > 0) + { + versionID = [email protected](); + } + flashPlayerVersions.push(versionString); + if (!_os.isLinux() || Number(versionString) <= 11.2) + { + var swfVersion:String = flashVersion.swfversion.toString(); + var flashPath:String = flashVersion.path.toString(); + var flashFile:String = flashVersion.file.toString(); + FLASH_PLAYER_VERSIONS.addItem({ + label: "Flash Player " + displayVersion, version: versionString, swfVersion: swfVersion, + versionID: versionID, path: flashPath, file: flashFile + }); + } + } + + if (this.flashPlayerVersion.selectedIndex == -1) + { + this.flashPlayerVersion.selectedIndex = flashPlayerVersions.indexOf(selected); + } + } + + ADOBE_AIR_SDK_WIN_FILE = data.airsdk.windows.versions.children().(@version == AIR_VERSION).file.toString(); + ADOBE_AIR_SDK_WIN_URL = data.airsdk.windows.versions.children().(@version == AIR_VERSION).path.toString(); + if (_os.isWindows() && (!ADOBE_AIR_SDK_WIN_FILE || !ADOBE_AIR_SDK_WIN_URL)) + { + log(_viewResourceConstants.ERROR_INVALID_AIR_SDK_URL_WINDOWS); + keepGoing = false; + } + ADOBE_AIR_SDK_WIN_URL += ADOBE_AIR_SDK_WIN_FILE; + + ADOBE_AIR_SDK_MAC_FILE = data.airsdk.mac.versions.children().(@version == AIR_VERSION).file.toString(); + ADOBE_AIR_SDK_MAC_URL = data.airsdk.mac.versions.children().(@version == AIR_VERSION).path.toString(); + if (_os.isMac() && (!ADOBE_AIR_SDK_MAC_FILE || !ADOBE_AIR_SDK_MAC_URL)) + { + log(_viewResourceConstants.ERROR_INVALID_AIR_SDK_URL_MAC); + keepGoing = false; + } + ADOBE_AIR_SDK_MAC_URL += ADOBE_AIR_SDK_MAC_FILE; + + ADOBE_AIR_SDK_LINUX_FILE = data.airsdk.linux.versions.children().(@version == AIR_VERSION).file.toString(); + ADOBE_AIR_SDK_LINUX_URL = data.airsdk.linux.versions.children().(@version == AIR_VERSION).path.toString(); + if (_os.isLinux() && (!ADOBE_AIR_SDK_LINUX_FILE || !ADOBE_AIR_SDK_LINUX_URL)) + { + log(_viewResourceConstants.ERROR_INVALID_AIR_SDK_URL_LINUX); + keepGoing = false; + } + ADOBE_AIR_SDK_LINUX_URL += ADOBE_AIR_SDK_LINUX_FILE; + + ADOBE_FB_GLOBALPLAYER_SWC_FILE = data.flashsdk.versions.children().(@version == FLASH_PLAYER_VERSION).file.toString(); + ADOBE_FB_GLOBALPLAYER_SWC_URL = data.flashsdk.versions.children().(@version == FLASH_PLAYER_VERSION).path.toString(); + FLASH_PLAYER_SWF_VERSION = data.flashsdk.versions.children().(@version == FLASH_PLAYER_VERSION).swfversion.toString(); + if (!ADOBE_FB_GLOBALPLAYER_SWC_FILE || !ADOBE_FB_GLOBALPLAYER_SWC_URL) + { + log(_viewResourceConstants.ERROR_INVALID_FLASH_PLAYER_SWC_URL); + keepGoing = false; + } + ADOBE_FB_GLOBALPLAYER_SWC_URL += ADOBE_FB_GLOBALPLAYER_SWC_FILE; + + SWF_OBJECT_FILE = [email protected](); + SWF_OBJECT_URL = [email protected](); + + //Supporting OSMF 2.0 from 4.11 onwards. + if (APACHE_FLEX_BIN_DISTRO_VERSION == "4.9.1" || APACHE_FLEX_BIN_DISTRO_VERSION == "4.10.0") + { + OSMF_SWC_FILE = [email protected](); + OSMF_SWC_URL = [email protected](); + _useOSMF2 = false; + } + else + { + OSMF_SWC_FILE = data["OSMF_SWC_2.0"][email protected](); + OSMF_SWC_URL = data["OSMF_SWC_2.0"][email protected](); + _useOSMF2 = true; + } + + BLAZEDS_FILE = [email protected](); + BLAZEDS_URL = [email protected](); + + AFE_FILE = [email protected](); + AFE_URL = [email protected](); + + AGLJ40_FILE = [email protected](); + AGLJ40_URL = [email protected](); + + FLEX_FONTKIT_FILE = data.fontswf["flex-fontkit"][email protected](); + FLEX_FONTKIT_URL = data.fontswf["flex-fontkit"][email protected](); + + RIDEAU_FILE = [email protected](); + RIDEAU_URL = [email protected](); + + + return keepGoing; + } + + protected function updateFlexVersionStrings(selectedFlexVersionObject:Object):void + { + APACHE_FLEX_BIN_DISTRO_FILE_SHORT = selectedFlexVersionObject.shortName; + APACHE_FLEX_BIN_DISTRO_VERSION = selectedFlexVersionObject.version; + APACHE_FLEX_BIN_DISTRO_VERSION_DISPLAY = selectedFlexVersionObject.label; + + APACHE_FLEX_BIN_DISTRO_FILE = selectedFlexVersionObject.fileName; + APACHE_FLEX_BIN_DISTRO_PATH = selectedFlexVersionObject.path; + legacy = selectedFlexVersionObject.legacy; + nocache = selectedFlexVersionObject.nocache; + APACHE_FLEX_BIN_INSTALLER_FILE = selectedFlexVersionObject.prefix + "installer-config.xml"; + + // ApacheFlex is full URL so download directly and dont use mirror useful for testing release candidates + if (APACHE_FLEX_BIN_DISTRO_PATH.indexOf("http") == 0) + { + _useMirror = false; + } + else + { + _useMirror = true; + } + + newSDKSelected = true; + } + + private function useMirrorPath(path:String):String + { + if (_useMirror) + { + return path; + } + + return ""; + } + + private function getMirrorURLResultHandler():void + { + var logMessages:ArrayCollection = ILog(_mirrorURLUtil).log; + var i:int; + var n:int = logMessages.length; + for (i = 0; i < n; i++) + { + log(String(logMessages.getItemAt(i))); + } + + if (_mirrorURLUtil.errorOccurred) + { + abortInstallation("mirrorURLUtil.errorOccurred"); + main(); + } + else + { + updatePaths(); + } + + } + + protected function updatePaths():void + { + if (APACHE_FLEX_BIN_DISTRO_PATH.substr(0, Constants.URL_PREFIX.length) == Constants.URL_PREFIX + || APACHE_FLEX_BIN_DISTRO_PATH.substr(0, Constants.FILE_PREFIX.length) == Constants.FILE_PREFIX + || APACHE_FLEX_BIN_DISTRO_PATH.substr(0, Constants.HTTPS_PREFIX.length) == Constants.HTTPS_PREFIX) + { + APACHE_FLEX_BIN_DISTRO_URL = APACHE_FLEX_BIN_DISTRO_PATH + APACHE_FLEX_BIN_DISTRO_FILE; + if (stepsOverride != "") + { + APACHE_FLEX_BIN_INSTALLER_URL = stepsOverride; + } + else + { + APACHE_FLEX_BIN_INSTALLER_URL = APACHE_FLEX_BIN_DISTRO_PATH + APACHE_FLEX_BIN_INSTALLER_FILE; + } + } + else + { + APACHE_FLEX_BIN_DISTRO_URL = useMirrorPath(_mirrorURLUtil.mirrorURL) + APACHE_FLEX_BIN_DISTRO_PATH + APACHE_FLEX_BIN_DISTRO_FILE; + if (stepsOverride != "") + { + APACHE_FLEX_BIN_INSTALLER_URL = stepsOverride; + } + else + { + APACHE_FLEX_BIN_INSTALLER_URL = MD5CompareUtil.MD5_DOMAIN + APACHE_FLEX_BIN_DISTRO_PATH + APACHE_FLEX_BIN_INSTALLER_FILE; + } + } + + if (installerAppPath.substr(0, Constants.URL_PREFIX.length) != Constants.URL_PREFIX) + { + installerAppPath = useMirrorPath(_mirrorURLUtil.mirrorURL) + installerAppPath; + } + + main(); + } + + protected function main():void + { + + if (shouldUpdate()) + { + doUpdate(); + } + } + + private function logVersion():void + { + if (!loggedVersion) + { + //Current version + var applicationDescriptor:XML = NativeApplication.nativeApplication.applicationDescriptor; + var xmlns:Namespace = new Namespace(applicationDescriptor.namespace()); + var currentVersion:String = applicationDescriptor.xmlns::versionNumber.toString(); + + // Log the Installer version to help with any support issues that arise. + log("Installer version " + currentVersion + " (" + _os.os + ")", 0); + loggedVersion = true; + } + } + + protected function shouldUpdate():Boolean + { + var shouldUpdate:Boolean = false; + //Current version + var applicationDescriptor:XML = NativeApplication.nativeApplication.applicationDescriptor; + var xmlns:Namespace = new Namespace(applicationDescriptor.namespace()); + var currentVersion:String = applicationDescriptor.xmlns::versionNumber.toString(); + + logVersion(); + + var availBuildNumbers:Array = _latestVersion.split("."); + var currentBuildNumbers:Array = currentVersion.split("."); + + if (parseInt(availBuildNumbers[0]) > parseInt(currentBuildNumbers[0])) + { + return true; + } + else if (parseInt(availBuildNumbers[0]) == parseInt(currentBuildNumbers[0])) + { + if (parseInt(availBuildNumbers[1]) > parseInt(currentBuildNumbers[1])) + { + return true; + } + else if (parseInt(availBuildNumbers[1]) == parseInt(currentBuildNumbers[1])) + { + if (parseInt(availBuildNumbers[2]) > parseInt(currentBuildNumbers[2])) + { + return true; + } + } + } + return false; + + } + + protected function doUpdate():void + { + var updaterDialog:UpdaterDialog = UpdaterDialog(PopUpManager.createPopUp(this, UpdaterDialog, true)); + updaterDialog.addEventListener("close", handleUpdaterDialogClose); + updaterDialog.latestVersion = _latestVersion; + PopUpManager.centerPopUp(updaterDialog); + } + + protected function handleUpdaterDialogClose(event:Event):void + { + PopUpManager.removePopUp(IFlexDisplayObject(event.target)); + } + + protected function handleInstallBtnClick(event:MouseEvent):void + { + var airVersionID:String = airVersion.selectedItem.versionID; + var flashVersionID:String = flashPlayerVersion.selectedItem.versionID; + + log("SDK version " + APACHE_FLEX_BIN_DISTRO_VERSION_DISPLAY); + + if (flexVersion.selectedItem.needsAIR) + { + if (airVersionID) + { + log("AIR version " + airVersionID); + } + else + { + log("AIR version " + AIR_VERSION); + } + } + + if (flexVersion.selectedItem.needsFlash) + { + if (flashVersionID) + { + log("Flash Player version " + flashVersionID); + } + else + { + log("Flash Player version " + FLASH_PLAYER_VERSION); + } + } + + if (flexSDKTxtInput.text == "") + { + log(_viewResourceConstants.INFO_ENTER_VALID_FLEX_SDK_PATH); + } + else + { + _langSelect.enabled = false; + _flexHome = flexSDKTxtInput.text; + resetInstallStepsActivity(); + addOptionalComponentsToInstallSteps(); + this.currentState = "installState"; + install(); + } + } + + protected function handleZeroStepNextBtnClick(event:MouseEvent):void + { + directoryBtn.enabled = false; + + AIR_VERSION = airVersion.selectedItem.version; + var airVersionID:String = airVersion.selectedItem.versionID; + FLASH_PLAYER_VERSION = flashPlayerVersion.selectedItem.version; + var flashVersionID:String = flashPlayerVersion.selectedItem.versionID; + + setXMLVariables(); // as AIR and Flash version may of changed + + if (!legacy) + { + if (newSDKSelected) + { + var req:URLRequest = new URLRequest(APACHE_FLEX_BIN_INSTALLER_URL); + loader = new ApacheURLLoader(); + loader.dataFormat = URLLoaderDataFormat.TEXT; + loader.addEventListener(Event.COMPLETE, handleInstallerXMLLoaded); + loader.addEventListener(ErrorEvent.ERROR, handleInstallerXMLError); + loader.addEventListener(IOErrorEvent.IO_ERROR, handleInstallerXMLError); + + loader.load(req); + } + } + else + { + showDirectoryState(); + } + } + + protected function handleFirstStepBackBtnClick(event:MouseEvent):void + { + showDefaultState(); + } + + protected function handleSecondStepBackBtnClick(event:MouseEvent):void + { + showDirectoryState(); + } + + protected function handleFirstStepNextBtnClick(event:MouseEvent):void + { + // Quick check to see if the selected directory is writable + try + { + var f:File = new File(_flexHome + File.separator + "flex.txt"); + checkDirWritable(f); + } + catch (e:Error) + { + log(_viewResourceConstants.ERROR_UNABLE_TO_CREATE_TEMP_DIRECTORY); + flexSDKTxtInput.errorString = _viewResourceConstants.ERROR_DIR_REQUIRE_ADMIN_RIGHTS; + flexSDKTxtInput.prompt = _viewResourceConstants.ERROR_DIR_REQUIRE_ADMIN_RIGHTS; + updateActivityStep(_viewResourceConstants.STEP_CREATE_DIRECTORIES, StepItem.ERROR); + return; + } + + showOptionsState(); + } + + protected function handleInstallerXMLLoaded(event:Event):void + { + var data:XML = XML(event.target.data); + var localeList:Array = resourceManager.localeChain; + _installerComponentsDataProvider = new ArrayCollection(); + compList = data.component.copy(); + for each (var comp:XML in compList) + { + var vo:InstallerComponentVO = new InstallerComponentVO(getLocalizedString(comp, "label"), + getLocalizedString(comp, "message"), getLocalizedString(comp, "license"), + getLocalizedString(comp, "licenseURL"), + [email protected](), [email protected]() == "true"); + licensePropertyMap[[email protected]()] = vo; + _installerComponentsDataProvider.addItem(vo); + } + usingXML = true; + // progressLabels = data.progressLabels[0]; + installStepsData = data.steps.step; + var strings:XMLList = data.strings.string; + for each (var x:XML in strings) + { + var id:String = [email protected](); + if (id in _viewResourceConstants) + { + var val:String = getLocalizedString(x, null); + _viewResourceConstants[id] = val; + var pce:PropertyChangeEvent = PropertyChangeEvent.createUpdateEvent(this, id, "", val); + _viewResourceConstants.dispatchEvent(pce); + } + } + var props:XMLList = data.properties.property; + for each (x in props) + { + additionalProps[[email protected]()] = [email protected](); + } + currentState = "directoryState"; + } + + private function getLocalizedString(xml:XML, propName:String):String + { + var compBundle:XMLList; + for each (var locale:String in resourceManager.localeChain) + { + compBundle = xml[locale]; + if (compBundle.length() == 1) + { + if (propName) + { + var xmlList:XMLList = compBundle[0][propName]; + if (xmlList.length() == 1) + { + return xmlList[0].toString(); + } + } + else + { + var s:String = compBundle[0].toString(); + if (s.length > 0) + { + return s; + } + } + } + } + return ""; + } + + protected function handleInstallerXMLError(event:Event):void + { + log("Unable to load " + APACHE_FLEX_BIN_INSTALLER_URL); + abortInstallation("Unable to load " + APACHE_FLEX_BIN_INSTALLER_URL); + } + + protected function showDefaultState():void + { + zeroStepGroup.visible = true; + directoryBtn.enabled = true; + currentState = "default"; + } + + protected function showDirectoryState():void + { + initiateInstallStepsActivity(); + if (currentState != "optionsState") + { + initializeInstallerComponentsDataProvider(); + } + currentState = "directoryState"; + } + + protected function showOptionsState():void + { + currentState = "optionsState"; + checkIfAllRequiredComponentsPromptsAnswered(); + } + + protected function initiateInstallStepsActivity():void + { + _installationSteps = new ArrayCollection(); + + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_CREATE_DIRECTORIES)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_VERIFY_FLEX_SDK)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_UNZIP_FLEX_SDK)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_UNZIP_AIR_RUNTIME_KIT)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_REQUIRED_INSTALL_FLASH_PLAYER_GLOBAL_SWC)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_INSTALL_CONFIG_FILES)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_REQUIRED_INSTALL_SWFOBJECT)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_REQUIRED_INSTALL_OSMF)); + } + + protected function resetInstallStepsActivity():void + { + for each(var step:StepItem in _installationSteps) + { + step.status = StepItem.NORMAL; + } + } + + protected function addOptionalComponentsToInstallSteps():void + { + if (usingXML) + { + _installationSteps = new ArrayCollection(); + + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_CREATE_DIRECTORIES)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_VERIFY_FLEX_SDK)); + _installationSteps.addItem(new StepItem(_viewResourceConstants.STEP_UNZIP_FLEX_SDK)); + + for each (var stepData:XML in installStepsData) + { + var propName:String = [email protected](); + if (!propName || InstallerComponentVO(licensePropertyMap[propName]).selected) + { + var si:StepItem = new StepItem(getLocalizedString(stepData, null)); + _installationSteps.addItem(si); + stepIDs.push([email protected]()); + stepLabels.push(si.label); + } + } + return; + } + for each (var obj:InstallerComponentVO in _installerComponentsDataProvider) + { + if (!obj.required && obj.selected) + { + _installationSteps.addItem(new StepItem(obj.label)); + } + } + } + + protected function initializeInstallerComponentsDataProvider():void + { + var versionNum:int = int(APACHE_FLEX_BIN_DISTRO_VERSION.split('.').join('')); + _installerComponentsDataProvider = new ArrayCollection(); + /** + * version 4.13.0 of the SDK is when the installer started using the new xml based + * way of displaying/updating required or optional components of the installer + */ + if (usingXML && (versionNum >= 4130)) + { + for each (var comp:XML in compList) + { + var vo:InstallerComponentVO = new InstallerComponentVO(getLocalizedString(comp, "label"), + getLocalizedString(comp, "message"), getLocalizedString(comp, "license"), + getLocalizedString(comp, "licenseURL"), + [email protected](), [email protected]() == "true"); + licensePropertyMap[[email protected]()] = vo; + _installerComponentsDataProvider.addItem(vo); + } + } + else + { + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK, + _viewResourceConstants.ASK_APACHE_FLEX, _viewResourceConstants.LICENSE_APACHE_V2, + _viewResourceConstants.LICENSE_URL_APACHE_V2, + "STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK", true)); + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, + _viewResourceConstants.ASK_ADOBE_AIR_SDK, + _viewResourceConstants.LICENSE_ADOBE_AIR_SDK, + _viewResourceConstants.LICENSE_URL_ADOBE_AIR_SDK, + "STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK", true)); + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_REQUIRED_INSTALL_FLASH_PLAYER_GLOBAL_SWC, + _viewResourceConstants.ASK_ADOBE_FLASH_PLAYER_GLOBAL_SWC, + _viewResourceConstants.LICENSE_ADOBE_SDK, + _viewResourceConstants.LICENSE_URL_ADOBE_SDK, + "STEP_REQUIRED_INSTALL_FLASH_PLAYER_GLOBAL_SWC", true)); + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_REQUIRED_INSTALL_SWFOBJECT, + _viewResourceConstants.ASK_SWFOBJECT, + _viewResourceConstants.LICENSE_SWFOBJECT, + _viewResourceConstants.LICENSE_URL_SWFOBJECT, + "STEP_REQUIRED_INSTALL_SWFOBJECT", true)); + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_REQUIRED_INSTALL_OSMF, + _viewResourceConstants.ASK_OSMF, + _viewResourceConstants.LICENSE_OSMF, + _viewResourceConstants.LICENSE_URL_OSMF, + "STEP_REQUIRED_INSTALL_OSMF", true)); + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_OPTIONAL_INSTALL_BLAZEDS, + _viewResourceConstants.ASK_BLAZEDS, + _viewResourceConstants.LICENSE_BLAZEDS, + _viewResourceConstants.LICENSE_URL_BLAZEDS, + "STEP_OPTIONAL_INSTALL_BLAZEDS", false)); + _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_OPTIONAL_INSTALL_FONTSWF, + _viewResourceConstants.ASK_FONTSWF, + _viewResourceConstants.LICENSE_FONTSWF, + _viewResourceConstants.LICENSE_URL_FONTSWF, + "STEP_OPTIONAL_INSTALL_FONTSWF", false)); +// _installerComponentsDataProvider.addItem(new InstallerComponentVO(_viewResourceConstants.STEP_REQUIRED_INSTALL_OFL_FONTS, +// _viewResourceConstants.ASK_OFL_FONTS, +// _viewResourceConstants.LICENSE_OFL_FONTS, +// _viewResourceConstants.LICENSE_URL_OFL_FONTS, +// "STEP_REQUIRED_INSTALL_OFL_FONTS", true)); + } + } + + protected function install():void + { + createDirectories(); + } + + protected function handleAirVersionChange(event:Event):void + { + AIR_VERSION = airVersion.selectedItem.version; + + // Match AIR and Flash versions + if (flashPlayerVersion.selectedIndex != airVersion.selectedIndex) + { + flashPlayerVersion.selectedIndex = airVersion.selectedIndex; + FLASH_PLAYER_VERSION = FLASH_PLAYER_VERSIONS[airVersion.selectedIndex].version; + } + } + + protected function handleFlashPlayerVersionChange(event:Event):void + { + FLASH_PLAYER_VERSION = flashPlayerVersion.selectedItem.version; + + // Match AIR and Flash versions + if (airVersion.selectedIndex != flashPlayerVersion.selectedIndex) + { + airVersion.selectedIndex = flashPlayerVersion.selectedIndex; + AIR_VERSION = AIR_VERSIONS[flashPlayerVersion.selectedIndex].version; + } + } + + protected function handleFlexVersionChange(event:Event):void + { + /*APACHE_FLEX_BIN_DISTRO_VERSION = flexVersion.selectedItem.version; + APACHE_FLEX_BIN_DISTRO_VERSION_DISPLAY = flexVersion.selectedItem.label;*/ + var item:Object = flexVersion.selectedItem; + airVersion.enabled = item.needsAIR; + flashPlayerVersion.enabled = item.needsFlash; + updateFlexVersionStrings(item); + updatePaths(); + updateWindowTitle(); + InstallApacheFlexSkin(skin).textIcon.source = item.icon; + } + + protected function browseForSDK(event:MouseEvent):void + { + var file:File = new File(); + + file.addEventListener(Event.SELECT, flexSDKDirSelected, false, 0, true); + file.browseForDirectory(_viewResourceConstants.INFO_SELECT_DIRECTORY); + } + + protected function checkDirWritable(file:File):void + { + var ba:ByteArray = new ByteArray(); + ba.writeUTFBytes("1"); + writeFileToDirectory(file, ba); + file.deleteFile(); + } + + protected function flexSDKDirSelected(event:Event):void + { + var selectedDir:File = File(event.target); + var overlay:Boolean = flexVersion.selectedItem.overlay; + + // Quick check to see if the selected directory is writable + try + { + var f:File = new File(selectedDir.nativePath + File.separator + "flex.txt"); + checkDirWritable(f); + } + catch (e:Error) + { + log(_viewResourceConstants.ERROR_UNABLE_TO_CREATE_TEMP_DIRECTORY); + log(_viewResourceConstants.ERROR_DIR_REQUIRE_ADMIN_RIGHTS); + flexSDKTxtInput.text = selectedDir.nativePath; + flexSDKTxtInput.errorString = _viewResourceConstants.ERROR_DIR_REQUIRE_ADMIN_RIGHTS + " : " + selectedDir.nativePath; // tooltip + flexSDKTxtInput.prompt = _viewResourceConstants.ERROR_DIR_REQUIRE_ADMIN_RIGHTS; // field + updateActivityStep(_viewResourceConstants.STEP_CREATE_DIRECTORIES, StepItem.ERROR); + return; + } + + overlaying = overlay; + if (!overlay) + { + if (isDirectoryEmpty(selectedDir)) + { + _flexHome = selectedDir.nativePath; + flexSDKTxtInput.text = _flexHome; + nextBtn.enabled = true; + _langSelect.enabled = true; + flexSDKTxtInput.errorString = ""; + flexSDKTxtInput.prompt = _viewResourceConstants.SELECT_PATH_PROMPT; + } + else + { + nextBtn.enabled = false; + flexSDKTxtInput.text = selectedDir.nativePath; + flexSDKTxtInput.errorString = _viewResourceConstants.ERROR_DIR_NOT_EMPTY + " : " + selectedDir.nativePath; + flexSDKTxtInput.prompt = _viewResourceConstants.ERROR_DIR_NOT_EMPTY; + } + } + else + { + _flexHome = selectedDir.nativePath; + flexSDKTxtInput.text = _flexHome; + nextBtn.enabled = true; + _langSelect.enabled = true; + flexSDKTxtInput.errorString = ""; + flexSDKTxtInput.prompt = _viewResourceConstants.SELECT_PATH_PROMPT; + } + } + + protected function handleFlexSDXTxtInputChange(event:TextOperationEvent):void + { + var tempDir:File; + var path:String = flexSDKTxtInput.text; + + try + { + tempDir = new File(path); + + if (isDirectoryEmpty(tempDir)) + { + flexSDKTxtInput.errorString = ""; + _flexHome = path; + nextBtn.enabled = true; + _langSelect.enabled = true; + } + else + { + flexSDKTxtInput.errorString = _viewResourceConstants.ERROR_INVALID_FLEX_SDK_DIRECTORY; + nextBtn.enabled = false; + } + } + catch (e:Error) + { + flexSDKTxtInput.errorString = _viewResourceConstants.ERROR_INVALID_FLEX_SDK_DIRECTORY; + nextBtn.enabled = false; + } + } + + protected function createDirectories():void + { + updateActivityStep(_viewResourceConstants.STEP_CREATE_DIRECTORIES, StepItem.ACTIVE); + + try + { + if (!overlaying) + { + log(_viewResourceConstants.INFO_CREATING_FLEX_HOME); + } + _flexHomeDir = createFolder(_flexHome); + log(_viewResourceConstants.INFO_CREATING_TEMP_DIR); + _flexTemp = _flexHome + File.separator + "temp"; + _flexTempDir = createFolder(_flexTemp); + updateActivityStep(_viewResourceConstants.STEP_CREATE_DIRECTORIES, StepItem.COMPLETE); + downloadApacheFlexSDK(); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_CREATE_DIRECTORIES, StepItem.ERROR); + log(_viewResourceConstants.ERROR_UNABLE_TO_CREATE_TEMP_DIRECTORY); + abortInstallation(_viewResourceConstants.ERROR_UNABLE_TO_CREATE_TEMP_DIRECTORY); + } + } + + protected function downloadApacheFlexSDK():void + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK, StepItem.ACTIVE); + + try + { + log(_viewResourceConstants.INFO_DOWNLOADING_FLEX_SDK + APACHE_FLEX_BIN_DISTRO_URL); + _apacheFlexSDKCompressedFile = File.userDirectory.resolvePath(_flexTemp + File.separator + APACHE_FLEX_BIN_DISTRO_FILE); + copyOrDownload(APACHE_FLEX_BIN_DISTRO_URL, handleApacheFlexSDKDownload, _apacheFlexSDKCompressedFile, handleApacheFlexSDKDownloadError, nocache); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK, StepItem.ERROR); + log(_viewResourceConstants.ERROR_UNABLE_TO_CREATE_TEMP_DIRECTORY + "(error: " + e.message); + abortInstallation(_viewResourceConstants.ERROR_UNABLE_TO_CREATE_TEMP_DIRECTORY + "(error: " + e.message); + } + + } + + protected function handleApacheFlexSDKDownload(event:Event):void + { + try + { + writeFileToDirectory(_apacheFlexSDKCompressedFile, event.target.data); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK, StepItem.ERROR); + abortInstallation("handleApacheFlexSDKDownload " + e.message); + } + + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK, StepItem.COMPLETE); + + updateActivityStep(_viewResourceConstants.STEP_VERIFY_FLEX_SDK, StepItem.ACTIVE); + + log(_viewResourceConstants.STEP_VERIFY_FLEX_SDK); + + _md5CompareUtil.addEventListener(ProgressEvent.PROGRESS, md5VerificationProgressHandler); + _md5CompareUtil.verifyMD5(_apacheFlexSDKCompressedFile, APACHE_FLEX_BIN_DISTRO_PATH + APACHE_FLEX_BIN_DISTRO_FILE, uncompressApacheFlexSDK); + } + + protected function md5VerificationProgressHandler(event:ProgressEvent):void + { + if (logProgressEvents) + { + log("md5 progress " + event.bytesLoaded + " " + event.bytesTotal, -1, false); + } + if (event.bytesTotal > 0) + { + progressBar.percent = Math.round((event.bytesLoaded / event.bytesTotal) * 100); + } + } + + protected function handleApacheFlexSDKDownloadError(event:* = null):void + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_APACHE_FLEX_SDK, StepItem.ERROR); + log(_viewResourceConstants.ERROR_UNABLE_TO_DOWNLOAD_FLEX_SDK); + abortInstallation(_viewResourceConstants.ERROR_UNABLE_TO_DOWNLOAD_FLEX_SDK); + } + + protected function uncompressApacheFlexSDK():void + { + if (_md5CompareUtil.validMD5) + { + if (!_md5CompareUtil.fileIsVerified) + { + updateActivityStep(_viewResourceConstants.STEP_VERIFY_FLEX_SDK, StepItem.ERROR); + + log(_viewResourceConstants.ERROR_VERIFY_FLEX_SDK); + + abortInstallation(_viewResourceConstants.ERROR_VERIFY_FLEX_SDK); + return; + } + else + { + updateActivityStep(_viewResourceConstants.STEP_VERIFY_FLEX_SDK, StepItem.COMPLETE); + log(_viewResourceConstants.INFO_VERIFY_FLEX_SDK_DONE); + } + } + else + { + updateActivityStep(_viewResourceConstants.STEP_VERIFY_FLEX_SDK, StepItem.COMPLETE); + + log(_viewResourceConstants.INFO_VERIFY_FLEX_SDK_DONE); + } + + updateActivityStep(_viewResourceConstants.STEP_UNZIP_FLEX_SDK, StepItem.ACTIVE); + + try + { + log(_viewResourceConstants.INFO_UNZIPPING + _apacheFlexSDKCompressedFile.nativePath); + + if (_os.isWindows()) + { + unzip(_apacheFlexSDKCompressedFile, handleApacheFlexSDKZipFileUnzipComplete, handleApacheFlexSDKZipFileUnzipError); + } + else + { + untar(_apacheFlexSDKCompressedFile, _flexTempDir, handleApacheFlexSDKZipFileUnzipComplete, handleApacheFlexSDKZipFileUnzipError); + } + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_UNZIP_FLEX_SDK, StepItem.ERROR); + abortInstallation(_viewResourceConstants.STEP_UNZIP_FLEX_SDK + " " + e.message); + } + } + + protected function handleApacheFlexSDKZipFileUnzipComplete(event:Event):void + { + log(_viewResourceConstants.INFO_FINISHED_UNZIPPING + _apacheFlexSDKCompressedFile.nativePath); + updateActivityStep(_viewResourceConstants.STEP_UNZIP_FLEX_SDK, StepItem.COMPLETE); + + if (_os.isWindows()) + { + if (usingXML) + { + runInstallerScript(); + } + else + { + downloadAIRRuntimeKitForWindows(); + } + } + else + { + if (!overlaying) + { + /* Copy all files from the unarchived directory to the root */ + var directory:File = _flexTempDir.resolvePath(APACHE_FLEX_BIN_DISTRO_FILE_SHORT); + var files:Array = directory.getDirectoryListing(); + for each(var file:File in files) + { + file.copyTo(_flexHomeDir.resolvePath(file.name)); + } + } + if (usingXML) + { + runInstallerScript(); + } + else + { + if (_os.isMac()) + { + downloadAIRRuntimeKitForMac(); + } + else + { + downloadAIRRuntimeKitForLinux(); + } + } + } + } + + protected function handleApacheFlexSDKZipFileUnzipError(error:ErrorEvent = null):void + { + updateActivityStep(_viewResourceConstants.STEP_UNZIP_FLEX_SDK, StepItem.ERROR); + abortInstallation(_viewResourceConstants.STEP_UNZIP_FLEX_SDK + " " + error.toString()); + } + + protected function runInstallerScript():void + { + ant = new Ant(); + ant.output = output; + + var file:File; + if (installOverride != "") + { + file = new File(installOverride); + } + else if (overlaying) + { + var directory:File = _flexTempDir.resolvePath(APACHE_FLEX_BIN_DISTRO_FILE_SHORT); + if (_os.isWindows()) + { + file = _flexTempDir.resolvePath("installer.xml"); + } + else + { + file = directory.resolvePath("installer.xml"); + } + } + else + { + file = _flexHomeDir.resolvePath("installer.xml"); + } + addEventListener(Event.ENTER_FRAME, enterFrameHandler); + var context:Object = {installer: true}; + if (usingDownloadCache) + { + context["usingDownloadCache"] = usingDownloadCache; + context["downloadCacheFolder"] = downloadCacheFolder; + } + if (configOverride != "") + { + context["xml.properties"] = configOverride; + } + if (resourceManager.localeChain.length > 1) + { + context["bundle"] = resourceManager.localeChain[0]; + } + for (var p:String in licensePropertyMap) + { + if (InstallerComponentVO(licensePropertyMap[p]).selected) + { + context[p] = true; + } + } + for (p in additionalProps) + { + context[p] = additionalProps[p]; + } + + context["air.sdk.version"] = AIR_VERSION; + if (airVersion.selectedItem.versionID) + { + context["air.sdk.versionID"] = airVersion.selectedItem.versionID; + } + context["air.sdk.url.path"] = airVersion.selectedItem.path; + context["air.sdk.url.file"] = airVersion.selectedItem.file; + context["flash.sdk.version"] = FLASH_PLAYER_VERSION; + if (flashPlayerVersion.selectedItem.versionID) + { + context["flash.sdk.versionID"] = flashPlayerVersion.selectedItem.versionID; + } + if (debugMode) + { + context["verbose"] = true; + } + if (flashPlayerVersion.selectedItem.path) + { + context["flash.sdk.url.path"] = flashPlayerVersion.selectedItem.path; + context["flash.sdk.url.file"] = flashPlayerVersion.selectedItem.file; + } + + if (file.exists && !ant.processXMLFile(file, context, true)) + { + ant.addEventListener(Event.COMPLETE, completeHandler); + ant.addEventListener(ProgressEvent.PROGRESS, progressEventHandler); + } + else + { + completeHandler(null); + } + } + + private function progressEventHandler(event:ProgressEvent):void + { + if (logProgressEvents) + { + log("progress " + event.bytesLoaded + " " + event.bytesTotal, -1, false); + } + if (event.bytesTotal > 0) + { + progressBar.percent = Math.round((event.bytesLoaded / event.bytesTotal) * 100); + } + /* + if (ant.progressClass is Copy) + { + progressBar.label = getLocalizedString(progressLabels, "Copy"); + } + else if (ant.progressClass is Get) + { + progressBar.label = getLocalizedString(progressLabels, "Get"); + } + else if (ant.progressClass is Checksum) + { + progressBar.label = getLocalizedString(progressLabels, "Checksum"); + } + */ + } + + private function completeHandler(event:Event):void + { + if (Ant.currentAnt && !Ant.currentAnt.project.status) + { + var msg:String = Ant.currentAnt.project.failureMessage; + log(msg ? msg : "no failure message provided"); + if (currentStep > 0) + { + updateActivityStep(stepLabels[currentStep - 1], StepItem.ERROR); + } + } + else if (currentStep == stepLabels.length && currentStep > 0) + { + updateActivityStep(stepLabels[currentStep - 1], StepItem.COMPLETE); + } + + if (Ant.currentAnt) + { + if (Ant.currentAnt.project.status) + { + tracker.trackInstallerSuccess(APACHE_FLEX_BIN_DISTRO_VERSION_DISPLAY, APACHE_FLEX_BIN_DISTRO_VERSION, _os.os); + } + if (Ant.currentAnt.project.failureMessage) + { + cleanup(!Ant.currentAnt.project.status, "&info=" + escape(Ant.currentAnt.project.failureMessage)); + } + else + { + cleanup(!Ant.currentAnt.project.status); + } + } + else + { + cleanup(); + } + } + + private var ant:Ant; + + private function output(s:String):void + { + var isPublic:Boolean = false; + var skipLog:Boolean = !debugMode; + if (s.indexOf(":") != -1 && s.charAt(0) == "\n") + { + // target output is a newline then the target name then a colon + if (currentStep < stepLabels.length && "\n" + stepIDs[currentStep] + ":" == s) + { + if (currentStep > 0) + { + updateActivityStep(stepLabels[currentStep - 1], StepItem.COMPLETE); + } + if (currentStep < stepLabels.length) + { + updateActivityStep(stepLabels[currentStep++], StepItem.ACTIVE); + } + } + isPublic = false; + } + else if (s.indexOf("[echo] ") != -1) + { + s = s.substr(s.indexOf("[echo] ") + 7); + isPublic = true; + skipLog = false; + } + else if (s.indexOf("[fail] ") != -1) + { + s = s.substr(s.indexOf("[fail] ") + 7); + isPublic = true; + skipLog = false; + } + log(s, -1, isPublic, skipLog); + } + + private function enterFrameHandler(event:Event):void + { + ant.doCallback(); + } + + protected function downloadAIRRuntimeKitForWindows():void + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ACTIVE); + + try + { + log(_viewResourceConstants.INFO_DOWNLOADING_AIR_RUNTIME_KIT_WINDOWS + ADOBE_AIR_SDK_WIN_URL); + _adobeAIRSDKZipFile = File.userDirectory.resolvePath(_flexTemp + File.separator + ADOBE_AIR_SDK_WIN_FILE); + copyOrDownload(ADOBE_AIR_SDK_WIN_URL, handleAIRSDKDownload, _adobeAIRSDKZipFile, handleAIRSDKDownloadError); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ERROR); + abortInstallation(); + } + } + + protected function downloadAIRRuntimeKitForMac():void + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ACTIVE); + + try + { + log(_viewResourceConstants.INFO_DOWNLOADING_AIR_RUNTIME_KIT_MAC + ADOBE_AIR_SDK_MAC_URL); + _adobeAIRSDKZipFile = File.userDirectory.resolvePath(_flexTemp + File.separator + ADOBE_AIR_SDK_MAC_FILE); + copyOrDownload(ADOBE_AIR_SDK_MAC_URL, handleAIRSDKDownload, _adobeAIRSDKZipFile, handleAIRSDKDownloadError); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ERROR); + abortInstallation(); + } + } + + protected function downloadAIRRuntimeKitForLinux():void + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ACTIVE); + + try + { + log(_viewResourceConstants.INFO_DOWNLOADING_AIR_RUNTIME_KIT_MAC + ADOBE_AIR_SDK_LINUX_URL); + _adobeAIRSDKZipFile = File.userDirectory.resolvePath(_flexTemp + File.separator + ADOBE_AIR_SDK_LINUX_FILE); + copyOrDownload(ADOBE_AIR_SDK_LINUX_URL, handleAIRSDKDownload, _adobeAIRSDKZipFile, handleAIRSDKDownloadError); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ERROR); + abortInstallation(); + } + } + + protected function handleAIRSDKDownload(event:Event):void + { + try + { + writeFileToDirectory(_adobeAIRSDKZipFile, event.target.data); + } + catch (e:Error) + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ERROR); + abortInstallation(); + } + + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.COMPLETE); + + unzipAdobeAIRSDK(); + } + + protected function handleAIRSDKDownloadError(error:* = null):void + { + updateActivityStep(_viewResourceConstants.STEP_REQUIRED_INSTALL_ADOBE_AIR_SDK, StepItem.ERROR); + log(_viewResourceConstants.ERROR_UNABLE_TO_DOWNLOAD_AIR_SDK); + abortInstallation(); + } + + protected function unzipAdobeAIRSDK():void + { + updateActivityStep(_viewResourceConstants.STEP_UNZIP_AIR_RUNTIME_KIT, StepI
<TRUNCATED> http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/cda78507/flex-installer/installer/src/assets/icons/114.png ---------------------------------------------------------------------- diff --git a/flex-installer/installer/src/assets/icons/114.png b/flex-installer/installer/src/assets/icons/114.png new file mode 100644 index 0000000..8f59da9 Binary files /dev/null and b/flex-installer/installer/src/assets/icons/114.png differ
