| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| package mx.automation.tool |
| { |
| import flash.display.Sprite; |
| import flash.events.Event; |
| import flash.utils.Timer; |
| |
| import mx.automation.AutomationHelper; |
| import mx.core.Application; |
| import mx.core.FlexGlobals; |
| import mx.core.UIComponent; |
| |
| public class ClientSocketHandler extends Sprite |
| { |
| |
| private static var socket:CustomSocket; |
| private static var currentToolAdapter:ToolAdapter; |
| |
| private var currentDataFromAppToAgent:ApplicationDataToAgent; |
| private var isInPartDataProcessing:Boolean; |
| |
| private var recordRequestsQueue:Array; // array of request data to be processed one after the other. |
| // this is to ensure that data will be sent synchronously one after the other. |
| // please note that in such cases we should not expect request back from the client. (other than |
| // for the incomplete processing. |
| // if we expect so, we need to figure out some other methods. // like we can indicate proceed to next only |
| // after recieveing an x data request from app. |
| |
| |
| private var count:int = 0; private var currentApplicationId:String; |
| private var applicationType:int; |
| |
| private var requestsSent:Array = new Array(); // for debugging... |
| // later may be we can remove this. |
| |
| private var responsesRecieved:Array = new Array(); // for debugging... |
| // later may be we can remove this. |
| |
| |
| // receiving data from Agent |
| private var currentDataFromAgent:Array = new Array(); |
| private static var insideIncompleteLoop:Boolean = false; |
| private var isInRecording:Boolean = false; |
| private var isToolInRecordingStatus:Boolean = false; |
| private var isToolInRunningStatus:Boolean = false; |
| |
| |
| |
| public static const separator:String = "|"; |
| private static const portNo:int = 2000; |
| |
| public static const dataEndIndicator:String = "__DATA_FROM_TOOL_AGENT__END__"; |
| public static const dataPartIndicator:String ="__DATA_FROM_TOOL_AGENT_PART__"; |
| |
| public static const dataToAgentEndIndicator:String = "__DATA_TO_TOOL_AGENT__END__"; |
| public static const dataToAgentPartIndicator:String ="__DATA_TO_TOOL_AGENT_PART__"; |
| |
| public static const dataStatusIndicatorLen:int = dataEndIndicator.length; |
| public static const requestToCompletePrev:String= "-CompletePrevious"; |
| |
| // both the end and the part string length should be the same |
| |
| // to agent strings |
| public static const startRequestString:String = "Start"; |
| public static const closeRequestString:String = "CloseSocket"; |
| public static const envRequestString:String = "ReqEnv"; |
| public static const recordRequestString:String = "Record"; |
| public static const activeScreenDataStoreRequestString:String = "StoreActiveScreen"; |
| public static const acceptApplicationBoundaryInScreenCoordinates:String = "AcceptAppBoundaryInScreenCoords"; |
| |
| // from agent strings |
| public static const nullValueIndicator:String= "__MX_NULL__"; |
| public static const emptyStringIndicator:String= "__MX_EMPTY_STRING__"; |
| |
| public static const socketStarted:String = "SocketStarted"; |
| public static const socketAccepted:String = "SocketAccepted"; |
| |
| public static const beginRecordInstructionString:String = "BeginRecording"; |
| public static const endRecordInstructionString:String = "EndRecording"; |
| |
| |
| public static const startRunInstructionString:String = "StartRunning"; |
| public static const endRunInstructionString:String = "EndRunning"; |
| |
| public static const setEnvInstructionString:String = "SetEnv"; |
| public static const sendRecordDetails:String = "SendRecordDetails"; |
| public static const finishedRecordIndicator:String = "FinishedRecordIndicator"; |
| public static const captureHandle:String = "CaptureWindowHandle"; |
| public static const captureHandleForNewWindow:String = "CaptureWindowHandleForNewWindow"; |
| public static const handleForNewWindowCaptured:String = "HandleForNewWindowCaptured"; |
| public static const getNewWindowDetails:String = "GetNewWindowDetails"; |
| public static const noNewWindow:String = "NoNewWindowCreatedDuringLastRun"; |
| |
| public static const isPointInside:String = "IsPointInside"; |
| public static const getElementFromPoint:String = "GetElementFromPoint"; |
| public static const getObjectType:String = "GetObjectType"; |
| public static const getParent:String = "GetParent"; |
| public static const getChildren:String = "GetChildren"; |
| public static const childrenSeparator:String = ":|:"; |
| public static const learnChildren:String = "LearnChildren"; |
| public static const leanrnChildrenIdXMLSeparator:String = "__ID_XML_SEP__"; |
| public static const leanrnChildrenIdsSeparator:String = "__IDS_SEP__"; |
| |
| public static const getDisplayName:String = "GetDisplayName"; |
| public static const getProperties:String = "GetProperties"; |
| public static const getProperties_ValueSeparator:String = "__MX_ARG_SEP__"; |
| public static const eventArgsSeparator:String = "__MX_EVNET_ARG_SEP__"; |
| public static const typeValueSeparator:String = "__MX_TYPE_VAL_SEP__"; |
| public static const recordInfoSeparator:String = "__MX_RECORD_INFO_SEP__"; |
| public static const recordNoArgIndicator:String = "FOR_TOOL_NO_ARGS_FROM_APP"; |
| public static const buildDescription:String = "BuildDescription"; |
| |
| public static const getTabularData:String = "GetTabularData"; |
| public static const getTabularDataArgSeparator:String = "__TABULAR_DATA_ARGS_SEP__"; |
| public static const getTabularData_Title_Table_Separator:String = "__TITLE_TABLE_DATA_SEP__"; |
| public static const getTabularData_Title_Data_Separator:String = "__TITLE_DATA_SEP__"; |
| public static const getTabularData_Table_Data_Separator:String = "__TABLE_DATA_SEP__"; |
| public static const getTabularAttributes:String = "GetTabularAttributes"; |
| |
| |
| public static const findObjectId:String = "FindObjectId"; |
| public static const findObjectId2:String = "FindObjectId2"; |
| public static const compareObjectIds:String = "CompareObjectIds"; |
| public static const objectIdSeparators:String = ":|:"; |
| |
| |
| public static const getRectangle:String = "GetRectangle"; |
| public static const rectangeInfoSeparator:String = ","; |
| |
| public static const run:String = "Run"; |
| public static const runParamSeparator:String = "__RUN_PARAM_SEP__"; |
| public static const getLastError:String="GetLastError"; |
| |
| |
| |
| public static const falseString:String = "Ret_False"; |
| public static const trueString:String = "Ret_True"; |
| |
| public static const idNamesSeparator:String = "__MX_ID_NAME_SEP__"; |
| public static const idFilterSeparator:String = "__MX_ID_FILT_SEP__"; |
| |
| public static const toAppDataMaxLength:int = 2500; |
| |
| |
| public static const appTypeAir:String = "Air"; |
| public static const appTypeFlex:String = "Flex"; |
| |
| private var tempCount:int = 0; |
| |
| private static var appAlpha:int = -1; |
| private var isInRunning :Boolean = false; |
| |
| public function ClientSocketHandler(adapter:ToolAdapter, currentAppId:String, appType:int ) |
| { |
| // create the client socket and request for connection. |
| |
| //store the application ID. we need this to be sent with every message. |
| currentApplicationId = currentAppId; |
| currentToolAdapter = adapter; |
| applicationType = appType; |
| |
| disableApplication(); |
| |
| ToolAdapter.showConnectionAttemptMessage(); |
| |
| // create a new socket and the port |
| socket = new CustomSocket("localhost", ClientSocketHandler.portNo); |
| socket.addEventListener(SocketResponseEvent.SOCKET_RESPONSE,responseHandler); |
| //socket.addEventListener(SocketResponseEvent.SOCKET_RESPONSE,RecordingHandler.handleResponse); |
| |
| var tempTimer:Timer = new Timer(5000,3); |
| tempTimer.addEventListener("timer", checkForConnection); |
| tempTimer.start(); |
| |
| |
| |
| } |
| |
| private static var _isDisabled:Boolean = false; |
| |
| public static function disableApplication():void |
| { |
| var appObj:UIComponent = FlexGlobals.topLevelApplication as UIComponent; |
| if(appObj) |
| { |
| // we need to handle all window disabling |
| appAlpha = appObj.alpha; |
| appObj.alpha= .4; |
| appObj.enabled = false; |
| _isDisabled = true; |
| } |
| } |
| |
| public static function enableApplication():void |
| { |
| if(_isDisabled) |
| { |
| var appObj:UIComponent = FlexGlobals.topLevelApplication as UIComponent; |
| if(appObj) |
| { |
| appObj.alpha= appAlpha; |
| appObj.enabled = true; |
| _isDisabled = false; |
| } |
| } |
| } |
| |
| public function addToRecordRequestQueue(requestObject:Object):int //Object of type RequestData |
| //Change for marshalling |
| { |
| |
| // this is to handle the multiple requests which needs to be |
| // processed for the record operation. |
| if( !recordRequestsQueue) |
| recordRequestsQueue = new Array(); |
| |
| return recordRequestsQueue.push(requestObject); |
| |
| } |
| |
| public function processQueuedRecordRequests(fromAgent:Boolean = false):Boolean |
| { |
| |
| var processed:Boolean = false; |
| if(fromAgent == true) |
| { |
| // process only if we are fresh in the list |
| // i.e only if we are not in the record processing |
| if((isInRecording == true)||(isInPartDataProcessing == true)) |
| { |
| //trace (" not processing the request from agent"); |
| return false; |
| } |
| |
| } |
| // this will send the stored erquest in order |
| // this will be called first from the recordHandler of the qtp and |
| // then once we get the record request back from the agent. |
| |
| |
| // it is quite possible that another record information got added to the queue |
| // when we were processing with the previous one. |
| // but we should not process this |
| // instead let the record processing mechanism to handle this |
| if(isInPartDataProcessing == false) |
| { |
| /* |
| if(fromAgent == true) |
| trace ("processing request from agent"); |
| else |
| trace ("processing request from end record info");*/ |
| |
| |
| if((recordRequestsQueue) && (recordRequestsQueue.length)) |
| { |
| isInRecording = true; |
| // we need to remove the elements in the order they were added. |
| //currentRequest is of type RequestData. Changed to Object to support Marshalling |
| var currentRequest:Object = recordRequestsQueue.shift(); |
| sendData(currentRequest.requestID, currentRequest.requestData); |
| |
| processed = true; |
| } |
| } |
| |
| return processed; |
| } |
| |
| private function getResponseDetails(responseString:String):Array |
| { |
| var details:Array = new Array(); |
| |
| // every response will have the following format |
| // id of the application|responseIdentifier|Response. |
| // get the application identifier. |
| // we need not blindly use split as there may be the same devider in the |
| // data part also. Hence read the tokens separately as we are interested only in the |
| // first two tokens. |
| var index:int = responseString.indexOf(ClientSocketHandler.separator); |
| var applicationId:String; |
| if(index > -1) |
| { |
| // get the applicationid |
| applicationId = responseString.substring(0,index); |
| } |
| |
| // proceed only if the current application id matches. |
| // this is just to ensure that we dont process the response sent to other application |
| // by mistake. (eventhough care will be taken from the server to send to the correct applicaiton) |
| if((applicationId) && (applicationId == currentApplicationId)) |
| { |
| |
| details.push(applicationId); |
| // get the response identifier |
| var index1:int = responseString.indexOf(ClientSocketHandler.separator,index+1); |
| if(index1 > -1) |
| { |
| // get the applicationid |
| var responseIdentifier:String = responseString.substring(index+1,index1); |
| details.push(responseIdentifier); |
| |
| // get the data |
| var index2:int = responseString.lastIndexOf(ClientSocketHandler.separator); |
| if(index2 > -1) |
| { |
| // get the data |
| var responseData:String = responseString.substring(index1+1,index2); |
| details.push(responseData); |
| |
| // get the response status indicator |
| var statusIndicator:String = responseString.substr(index2+1, responseString.length- (index2+1)); |
| details.push(statusIndicator); |
| |
| } |
| |
| } |
| } |
| |
| return details; |
| |
| } |
| |
| |
| |
| |
| private function combineCurrentData(currentData:Array):void |
| { |
| //if the current is not empty, then assign new |
| // else check all fields, and combine the data string - 3rd entry in the array |
| if(currentDataFromAgent && currentDataFromAgent.length==4 ) |
| { |
| // check whether all the data matches |
| // TBD validity check |
| var dataString:String = currentDataFromAgent[2]; |
| dataString = dataString + currentData[2]; |
| |
| currentDataFromAgent[2] = dataString ; |
| //trace (currentData[2]); |
| } |
| else |
| { |
| currentDataFromAgent = new Array(); |
| |
| currentDataFromAgent = currentData; |
| } |
| |
| |
| } |
| |
| private function clearCurrentData():void |
| { |
| currentDataFromAgent = new Array(); |
| } |
| |
| private var socketAccepted:Boolean = false; |
| private var connectionTrialCount:int = 0; |
| |
| private function checkForConnection(event:Event):void |
| { |
| connectionTrialCount ++; |
| if(connectionTrialCount == 3) |
| { |
| if (!socketAccepted) |
| { |
| ToolAdapter.showConnectionFailureMessage(); |
| } |
| } |
| } |
| |
| public function responseHandler(event:SocketResponseEvent):void |
| { |
| // dont process the request unless the air libraries are loaded |
| // properly |
| if(!AutomationHelper.isAirClassLoaded()) |
| return; |
| |
| // we need to process here only if the current response is not |
| // from recording |
| /* |
| if(event.isInRecordProcessing) |
| return ;*/ |
| |
| //dispatchEvent(new SocketResponseEvent(event.response,event.type)); |
| //trace ("from event"+ event.response); |
| // [0] - appID , [1] - Indentifier , [2] - Data |
| |
| if(event.response.length == 0) |
| { |
| |
| // we got the empty response. |
| // this happens after sending data and we dont get any response back from the applicaiton |
| // but this can be used to trigger the queded requests. |
| |
| if(isInPartDataProcessing == false) |
| { |
| // if we have some queued request process that. |
| //processQueuedRequests(); |
| } |
| } |
| else |
| { |
| |
| var responseDetails:Array = getResponseDetails(event.response); |
| |
| var responseString:String; |
| var processCurrentData:Boolean = false; |
| |
| if((responseDetails) && (responseDetails.length > 1)) |
| responseString = responseDetails[1]; |
| |
| if(responseString) |
| { |
| // check whether it is request for the part data completion |
| if(responseString.indexOf(ClientSocketHandler.requestToCompletePrev) != -1) |
| { |
| // this indicates that we are in the part processing |
| if(isInPartDataProcessing == false) |
| { |
| // this indicates programming or synchronisation error. |
| // ignore this |
| var a_nFalseExecution:int = 1; |
| trace ("ClientSocketHandler:responseHandler()-"+event.response); |
| trace ("ClientSocketHandler:responseHandler()-We should not have come here .... " + responseString); |
| } |
| else |
| { |
| // separate the actual string |
| responseString = responseString.substr(0,responseString.length-ClientSocketHandler.requestToCompletePrev.length); |
| sendCurrentPartData(responseString); |
| } |
| } |
| else |
| { |
| |
| if(isInPartDataProcessing == true) |
| { |
| trace ("ClientSocketHandler:responseHandler()-"+event.response); |
| trace ("ClientSocketHandler:responseHandler()- We should not have come here 2.... " + responseString); |
| } |
| // we have not recieved to send the previous incomplete information continuation. |
| // i.e the data recieved is for us to use and handle |
| // now check whether this data is complete or part |
| // check the status of the message |
| if(responseDetails.length > 3) |
| { |
| var statusIndicator:String = responseDetails[3]; |
| |
| // combine the current data with the existing |
| combineCurrentData(responseDetails); |
| |
| if(statusIndicator == dataEndIndicator) |
| { |
| insideIncompleteLoop = false; |
| processCurrentData = true; |
| } |
| else |
| { |
| insideIncompleteLoop = true; |
| processCurrentData = false; |
| } |
| } |
| |
| if(insideIncompleteLoop) |
| { |
| tempCount++; |
| // current dat is incomplete |
| // send request for the next set |
| sendData(currentDataFromAgent[1]+ClientSocketHandler.requestToCompletePrev); |
| } |
| else if(responseString && processCurrentData) |
| { |
| tempCount = 0; |
| |
| if(responseString == ClientSocketHandler.socketStarted) |
| { |
| // request the env details |
| sendData(ClientSocketHandler.startRequestString); |
| //tempTimer. |
| |
| } |
| // process the current data |
| else if(responseString == ClientSocketHandler.socketAccepted) |
| { |
| socketAccepted = true; |
| // request the env details |
| sendData(ClientSocketHandler.envRequestString); |
| |
| } |
| else if (responseString == ClientSocketHandler.handleForNewWindowCaptured) |
| { |
| ClientSocketHandler.isNewWindowRegistrationOver = true; |
| sendData(ClientSocketHandler.handleForNewWindowCaptured,""); |
| } |
| |
| else if(responseString == ClientSocketHandler.beginRecordInstructionString) |
| { |
| // start recording. |
| currentToolAdapter.beginRecording(); |
| isToolInRecordingStatus = true; |
| |
| |
| } |
| else if(responseString == ClientSocketHandler.endRecordInstructionString) |
| { |
| //end recording |
| currentToolAdapter.endRecording(); |
| isToolInRecordingStatus = false; |
| |
| } |
| else if(responseString == ClientSocketHandler.startRunInstructionString) |
| { |
| //end recording |
| isToolInRunningStatus = true; |
| } |
| else if(responseString == ClientSocketHandler.endRunInstructionString) |
| { |
| //end recording |
| isToolInRunningStatus = false; |
| } |
| else if(responseString == ClientSocketHandler.setEnvInstructionString) |
| { |
| if(responseDetails[2]) |
| currentToolAdapter.setTestingEnvironment(currentDataFromAgent[2]); |
| |
| // get the App Title |
| var appTitle:String = currentToolAdapter.getAppTitle(); |
| //trace ("App Title " + appTitle); |
| // send the request to capture the window handle |
| |
| enableApplication(); |
| ToolAdapter.showConnectionSuccessMessage(); |
| sendData(ClientSocketHandler.captureHandle, appTitle); |
| |
| } |
| else if(responseString == ClientSocketHandler.sendRecordDetails) |
| { |
| //trace ("calling processQueuedRecordRequests sendRecordDetails"); |
| // request to send the stored record information |
| processQueuedRecordRequests(); |
| } |
| else if(responseString == ClientSocketHandler.finishedRecordIndicator) |
| { |
| //trace ("calling processQueuedRecordRequests finishedRecordIndicator"); |
| |
| // if there are fresh record requests in the queue |
| // this will process that |
| // request to send the stored record information if any |
| if(recordRequestsQueue.length == 0) |
| { |
| isInRecording = false; |
| // during recording if the previos operation has |
| // resulted in a new window creation we need to process |
| // the same after the current recording is over. |
| processNewWindowRequestToTool(); |
| } |
| else |
| processQueuedRecordRequests(); |
| } |
| /* .. is pointinside is not called from plugin |
| plugin does a diff way of finding whehter the point belongs to the application |
| else if(responseString == ClientSocketHandler.isPointInside) |
| { |
| var dataToBeSent:String = ClientSocketHandler.falseString; |
| |
| if(currentDataFromAgent[2]) |
| { |
| var pointArray:Array = (currentDataFromAgent[2] as String).split(","); |
| var windowId:String; |
| if(pointArray.length == 3) |
| windowId = pointArray[2]; |
| if(pointArray.length >= 2) |
| { |
| var checkPoint:Point = new Point(pointArray[0], pointArray[1]); |
| var status:Boolean = currentToolAdapter.isScreenPointWithinStageBoundary(checkPoint,windowId); |
| if(status) |
| dataToBeSent = ClientSocketHandler.trueString; |
| } |
| |
| } |
| sendData(ClientSocketHandler.isPointInside, dataToBeSent); |
| |
| } |
| */ |
| else if(responseString == ClientSocketHandler.getElementFromPoint) |
| { |
| |
| var dataToBeSent1:String = ""; |
| if(currentDataFromAgent[2]) |
| { |
| var pointArray1:Array = (currentDataFromAgent[2] as String).split(","); |
| var object:Object = null; |
| if(pointArray1.length == 2) |
| object = currentToolAdapter.getElementFromPoint(pointArray1[0], pointArray1[1], ""); |
| else if(pointArray1.length == 3) |
| object = currentToolAdapter.getElementFromPoint(pointArray1[0], pointArray1[1],pointArray1[2] ); |
| |
| dataToBeSent1 = object["result"]; |
| |
| } |
| sendData(ClientSocketHandler.getElementFromPoint,dataToBeSent1 ); |
| } |
| else if(responseString == ClientSocketHandler.getObjectType) |
| { |
| var dataToBeSent2:String = ""; |
| var objectId:String = currentDataFromAgent[2]; |
| if(objectId) |
| { |
| var object2:Object = currentToolAdapter.getElementType(objectId); |
| dataToBeSent2 = object2["result"]; |
| } |
| sendData(ClientSocketHandler.getObjectType,dataToBeSent2 ); |
| } |
| else if(responseString == ClientSocketHandler.getParent) |
| { |
| var dataToBeSent3:String = ""; |
| var objectId2:String = currentDataFromAgent[2]; |
| if(objectId2) |
| { |
| var object3:Object = currentToolAdapter.getParent(objectId2); |
| dataToBeSent3 = object3["result"]; |
| } |
| sendData(ClientSocketHandler.getParent,dataToBeSent3 ); |
| } |
| else if(responseString == ClientSocketHandler.getDisplayName) |
| { |
| var dataToBeSent4:String = ""; |
| var objectId3:String = currentDataFromAgent[2]; |
| if(objectId3) |
| { |
| var object4:Object = currentToolAdapter.getDisplayName(objectId3); |
| dataToBeSent4 = object4["result"]; |
| } |
| sendData(ClientSocketHandler.getDisplayName,dataToBeSent4 ); |
| } |
| else if(responseString == ClientSocketHandler.getProperties) |
| { |
| var dataToBeSent5:String = ""; |
| var idAndNames:String = currentDataFromAgent[2]; |
| if(idAndNames) |
| { |
| // separate the idAndNames |
| var idAndNamesArray:Array = idAndNames.split(ClientSocketHandler.idNamesSeparator); |
| if(idAndNamesArray.length == 2) |
| { |
| var objectID5:String = idAndNamesArray[0]; |
| var names:String = idAndNamesArray[1]; |
| //trace("Properties requested for " + names); |
| |
| var object5:Object = currentToolAdapter.getProperties(objectID5,names); |
| var dataObjectArray:Array = object5["result"] as Array; |
| if(dataObjectArray) |
| dataToBeSent5 = dataObjectArray.join(ClientSocketHandler.getProperties_ValueSeparator); |
| |
| } |
| } |
| sendData(ClientSocketHandler.getProperties,dataToBeSent5 ); |
| } |
| else if(responseString == ClientSocketHandler.getRectangle) |
| { |
| var dataToBeSent6:String = ""; |
| var objectID6:String = currentDataFromAgent[2]; |
| if(objectID6) |
| { |
| var arr1:Array = currentToolAdapter.getRectangleInScreenCoordinates(objectID6); |
| dataToBeSent6 = arr1.join(ClientSocketHandler.rectangeInfoSeparator); |
| } |
| sendData(ClientSocketHandler.getRectangle,dataToBeSent6 ); |
| } |
| |
| else if(responseString == ClientSocketHandler.buildDescription) |
| { |
| var dataToBeSent7String:String = ""; |
| var objectID7:String = currentDataFromAgent[2]; |
| if(objectID7) |
| { |
| var object7:Object = currentToolAdapter.buildDescription(objectID7); |
| dataToBeSent7String = object7["result"]; |
| |
| } |
| sendData(ClientSocketHandler.buildDescription,dataToBeSent7String ); |
| } |
| else if(responseString == ClientSocketHandler.getChildren) |
| { |
| var dataToBeSent8:String = ""; |
| var objectID_And_Filter:String = currentDataFromAgent[2]; |
| if(objectID_And_Filter) |
| { |
| // separate the idAndNames |
| var objectID_And_FilterArray:Array = objectID_And_Filter.split(ClientSocketHandler.idFilterSeparator); |
| if(objectID_And_FilterArray.length == 2) |
| { |
| var objectID8:String = objectID_And_FilterArray[0]; |
| var filter:String = objectID_And_FilterArray[1]; |
| |
| var object8:Object = currentToolAdapter.getChildren(objectID8,filter); |
| var dataToBeSentArray8:Array = (object8["result"] as Array); |
| dataToBeSent8 = dataToBeSentArray8.join(ClientSocketHandler.childrenSeparator); |
| } |
| } |
| sendData(ClientSocketHandler.getChildren,dataToBeSent8 ); |
| } |
| else if(responseString == ClientSocketHandler.learnChildren) |
| { |
| var dataToBeSent9:String = ""; |
| var objectID_And_Filter1:String = currentDataFromAgent[2]; |
| if(objectID_And_Filter1) |
| { |
| // separate the idAndNames |
| var objectID_And_FilterArray1:Array = objectID_And_Filter1.split(ClientSocketHandler.idFilterSeparator); |
| if(objectID_And_FilterArray1.length == 2) |
| { |
| var objectID9:String = objectID_And_FilterArray1[0]; |
| var filter1:String = objectID_And_FilterArray1[1]; |
| |
| var object9:Object = currentToolAdapter.learnChildObjects(objectID9,filter1); |
| var dataobject9:Object = (object9["result"]); |
| |
| var dataToBeSentArray9:Array = new Array(); |
| dataToBeSentArray9.push(dataobject9["learnChildrenXML"]); |
| var childIDs:Array = (dataobject9["childrenIDs"] as Array) |
| dataToBeSentArray9.push( childIDs.join(ClientSocketHandler.leanrnChildrenIdsSeparator)); |
| dataToBeSent9 = dataToBeSentArray9.join(ClientSocketHandler.leanrnChildrenIdXMLSeparator); |
| } |
| } |
| sendData(ClientSocketHandler.learnChildren,dataToBeSent9); |
| } |
| |
| else if(responseString == ClientSocketHandler.run) |
| { |
| |
| isInRunning = true; |
| var dataToBeSent10:String = ""; |
| var objectID_Method_Arg_String:String = currentDataFromAgent[2]; |
| |
| if(objectID_Method_Arg_String) |
| { |
| // separate the idAndNames |
| var objectID_Method_Arg_Array:Array = objectID_Method_Arg_String.split(ClientSocketHandler.runParamSeparator); |
| if(objectID_Method_Arg_Array.length == 3) |
| { |
| |
| var objectID10:String = objectID_Method_Arg_Array[0]; |
| //trace (objectID10); |
| var method:String = objectID_Method_Arg_Array[1]; |
| var args:String = objectID_Method_Arg_Array[2]; |
| |
| var object10:Object = currentToolAdapter.run(objectID10,method,args); |
| |
| dataToBeSent10 = ""; |
| if(object10) |
| { |
| var resultObj10:Object =(object10["result"]); |
| if(resultObj10) |
| dataToBeSent10 = resultObj10["type"] + ClientSocketHandler.runParamSeparator+(resultObj10["value"]); |
| } |
| } |
| } |
| sendData(ClientSocketHandler.run,dataToBeSent10); |
| // we need to set it false only after we sending the |
| // new window processing |
| //isInRunning = false; |
| //processNewWindowRequestToTool(); |
| } |
| else if(responseString == ClientSocketHandler.getLastError) |
| { |
| var dataToBeSent11:String = ""; |
| |
| var object11:Object = currentToolAdapter.getLastError(); |
| dataToBeSent11 = (object11["result"]); |
| sendData(ClientSocketHandler.getLastError,dataToBeSent11); |
| } |
| |
| else if(responseString == ClientSocketHandler.getTabularData) |
| { |
| var dataToBeSent12:String = ""; |
| |
| var tabularDataArgs:String = currentDataFromAgent[2]; |
| if(tabularDataArgs) |
| { |
| // separate the idAndNames |
| var tabularDataArgsArray:Array = tabularDataArgs.split(ClientSocketHandler.getTabularDataArgSeparator); |
| if(tabularDataArgsArray.length == 3) |
| { |
| var objectID12:String = tabularDataArgsArray[0]; |
| var min:Number = Number(tabularDataArgsArray[1]); |
| var max:Number = Number(tabularDataArgsArray[2]); |
| |
| var object12:Object = currentToolAdapter.getTabularData(objectID12,min,max); |
| var dataobject12:Object = (object12["result"]); |
| |
| var dataToBeSentArray12:Array = new Array(); |
| |
| // Creating a dummy object to handle error in unusual cases like |
| // object being visible only at the time of inserting checkpoint |
| // but not being available before that. |
| // Ex: Volume bar in Spark Mutebutton control. |
| // It will not be visible before we click on insert checkpoint |
| // It can be made visible later by clicking on Ctrl. |
| // If it is visible before we click on insert checkpoint |
| // it will not be available in the child list of the application |
| // by the time we come back to the application. |
| // http://bugs.adobe.com/jira/browse/FLEXENT-1113 |
| if(!dataobject12) |
| { |
| dataobject12 = new Object(); |
| dataobject12["columnTitles"] = new Array(); |
| dataobject12["tableData"] = new Array(); |
| } |
| |
| var columnNamesString:String = (dataobject12["columnTitles"] as Array).join(ClientSocketHandler.getTabularData_Title_Data_Separator); |
| if(columnNamesString=="") |
| { |
| if((dataobject12["columnTitles"] as Array).length == 0) |
| columnNamesString = ClientSocketHandler.nullValueIndicator; |
| else |
| columnNamesString = ClientSocketHandler.emptyStringIndicator; |
| } |
| dataToBeSentArray12.push(columnNamesString); |
| var tableDataString:String = openArrayOfArrays(dataobject12["tableData"] as Array, ClientSocketHandler.getTabularData_Table_Data_Separator) |
| //var tableDataString:String = (dataobject12["tableData"] as Array).join(ClientSocketHandler.getTabularData_Table_Data_Separator); |
| if(tableDataString=="") |
| { |
| if((dataobject12["tableData"] as Array).length == 0) |
| tableDataString = ClientSocketHandler.nullValueIndicator; |
| else |
| tableDataString = ClientSocketHandler.emptyStringIndicator; |
| } |
| |
| dataToBeSentArray12.push(tableDataString); |
| dataToBeSent12 = dataToBeSentArray12.join(ClientSocketHandler.getTabularData_Title_Table_Separator); |
| } |
| } |
| sendData(ClientSocketHandler.getTabularData,dataToBeSent12); |
| } |
| else if(responseString == ClientSocketHandler.getTabularAttributes) |
| { |
| var dataToBeSent13:String = ""; |
| |
| var objectID13:String = currentDataFromAgent[2]; |
| if(objectID13) |
| { |
| // separate the idAndNames |
| var object13:Object = currentToolAdapter.getTabularAttributes(objectID13); |
| var dataobject13:Object = (object13["result"]); |
| |
| var dataToBeSentArray13:Array = new Array(); |
| if(dataobject13) |
| { |
| dataToBeSentArray13.push(dataobject13["fullSize"]); |
| dataToBeSentArray13.push(dataobject13["minVisibleRow"]); |
| dataToBeSentArray13.push(dataobject13["maxVisibleRow"]); |
| } |
| else |
| { |
| // Creating a dummy array to handle error in unusual cases like |
| // object being visible only at the time of inserting checkpoint |
| // but not being available before that. |
| // Ex: Volume bar in Spark Mutebutton control. |
| // It will not be visible before we click on insert checkpoint |
| // It can be made visible later by clicking on Ctrl. |
| // If it is visible before we click on insert checkpoint |
| // it will not be available in the child list of the application |
| // by the time we come back to the application. |
| // http://bugs.adobe.com/jira/browse/FLEXENT-1113 |
| dataToBeSentArray13.push(0); |
| dataToBeSentArray13.push(0); |
| dataToBeSentArray13.push(0); |
| } |
| dataToBeSent13 = dataToBeSentArray13.toString(); // we are using the normal array sep |
| } |
| sendData(ClientSocketHandler.getTabularAttributes,dataToBeSent13); |
| } |
| else if(responseString == ClientSocketHandler.findObjectId2) |
| { |
| var dataToBeSent14:String = ""; |
| |
| var descriptionXml14:String = currentDataFromAgent[2]; |
| if(descriptionXml14) |
| { |
| // separate the idAndNames |
| var object14:Object = currentToolAdapter.findObjectIDs(descriptionXml14); |
| var dataobject14:Array = (object14["result"] as Array); |
| |
| if(dataobject14) |
| dataToBeSent14 = dataobject14.join(ClientSocketHandler.objectIdSeparators); |
| |
| } |
| sendData(ClientSocketHandler.findObjectId2,dataToBeSent14); |
| } |
| else if(responseString == ClientSocketHandler.getNewWindowDetails) |
| { |
| processNewWindowRequestToTool(null,ClientSocketHandler.getNewWindowDetails,true); |
| // WE would have got this request as a part of a run |
| // refer the plugin run handling code. |
| // so only after we processing this request we need to set the flag to false. |
| if(isInRunning) |
| isInRunning = false; |
| } |
| //getLastError |
| clearCurrentData(); |
| } |
| } |
| } |
| else |
| { |
| trace ("event response is not normal" + event.response); |
| } |
| } |
| } |
| |
| private function openArrayOfArrays(passedArray:Array , delimiter:String):String |
| { |
| if(passedArray ) |
| { |
| var tempArr:Array = new Array(); |
| var index:int = 0; |
| var count:int = passedArray.length; |
| while(index < count) |
| { |
| var currentArray:Array = passedArray[index] as Array; |
| if(currentArray) |
| tempArr.push(currentArray.join(delimiter)); |
| else |
| tempArr.push(passedArray[index]); |
| index++; |
| } |
| return tempArr.join(delimiter); |
| } |
| else |
| return ""; |
| } |
| |
| private function processNewWindowRequestToTool(event:Event = null, newResposeIdString:String = null, |
| sendDataEvenOnNoNewWindow:Boolean = false):void |
| { |
| if(recordRequestsQueue && recordRequestsQueue.length) |
| return; |
| |
| var responseIdString:String ; |
| var dataString:String; |
| var toBeSent:Boolean = false; |
| if(newResposeIdString != null) |
| responseIdString = newResposeIdString; |
| |
| if(queuedNewWindowRequestsToSendToTool && queuedNewWindowRequestsToSendToTool.length) |
| { |
| var appData:ApplicationDataToAgent = queuedNewWindowRequestsToSendToTool.shift() as ApplicationDataToAgent; |
| dataString = appData.currentResponseData; |
| if(!responseIdString) |
| responseIdString = appData.currentResponseIdString; |
| } |
| else if (sendDataEvenOnNoNewWindow) |
| dataString = ClientSocketHandler.noNewWindow; |
| |
| if(dataString && responseIdString) |
| sendData(responseIdString,dataString); |
| } |
| |
| private var queuedNewWindowRequestsToSendToTool:Array = new Array(); |
| |
| public function sendData(requestIdentifier:String,dataString:String=""):void |
| { |
| // TBD handle when we get if we were already in part processing we should |
| // queue this request |
| |
| if(!dataString) |
| dataString = ClientSocketHandler.nullValueIndicator; |
| |
| // here we assume that we got the request from the new data sending. |
| requestsSent.push(requestIdentifier); |
| |
| if(!currentDataFromAppToAgent) |
| currentDataFromAppToAgent = new ApplicationDataToAgent(currentApplicationId,requestIdentifier,dataString); |
| else |
| currentDataFromAppToAgent.init(currentApplicationId,requestIdentifier,dataString); |
| |
| |
| |
| if(currentDataFromAppToAgent.willDataBePendingAfterNextSend()) |
| isInPartDataProcessing = true; |
| |
| if(currentDataFromAppToAgent.sendNextSet(requestIdentifier) > 0) |
| isInPartDataProcessing = true; |
| // means current data could not be completely sent |
| else |
| isInPartDataProcessing = false; |
| |
| |
| |
| } |
| |
| |
| private function sendCurrentPartData( responseIdentifier:String):void |
| { |
| if(currentDataFromAppToAgent.isDataRemaining() == false) |
| { |
| |
| trace("ClientSocketHandler:sendCurrentPartData()-This should not have happened. Last time data is not there and we received a part request."); |
| // send a forceful completion |
| currentDataFromAppToAgent.sendForcefulCompletion(responseIdentifier); |
| |
| } |
| else |
| { |
| if(currentDataFromAppToAgent.willDataBePendingAfterNextSend()) |
| isInPartDataProcessing = true; |
| |
| if(currentDataFromAppToAgent.sendNextSet(responseIdentifier) > 0) |
| isInPartDataProcessing = true; |
| else |
| isInPartDataProcessing = false; |
| } |
| |
| |
| } |
| |
| |
| public static function sendDataWithoutFormatting(dataString:String):void |
| { |
| // if the required air libraries could not be loaded, |
| // we should not proceed communicating to QTP. |
| // without certian information using the library (e.g applicationTitle) |
| // qtp will hang. |
| if(!AutomationHelper.isAirClassLoaded()) |
| return; |
| |
| //trace ("sending " + dataString); |
| |
| |
| //str = str.concat(String(count)); |
| if(socket.connected) |
| { |
| socket.sendRequestString(dataString); |
| socket.flush(); |
| socket.readResponse(); |
| } |
| } |
| |
| public function processNewWindowInformation(windowId:String):void |
| { |
| ClientSocketHandler.isNewWindowRegistrationOver = false; |
| |
| if(isToolInRecordingStatus && (AutomationHelper.isAirClassLoaded()) ) |
| disableApplication(); |
| |
| |
| if(isToolInRunningStatus || isToolInRecordingStatus) |
| { |
| // if we are getting this in the middle of recording or replaying |
| // let us add to the queued request and once the |
| // recording or replaying is over let us handle it. |
| var newDataFromAppToAgent:ApplicationDataToAgent = new ApplicationDataToAgent(currentApplicationId,ClientSocketHandler.captureHandleForNewWindow,windowId); |
| queuedNewWindowRequestsToSendToTool.push(newDataFromAppToAgent); |
| } |
| else |
| sendData(ClientSocketHandler.captureHandleForNewWindow, windowId); |
| |
| } |
| |
| private static var _isNewWindowRegistrationOver:Boolean = false; |
| public static function get isNewWindowRegistrationOver():Boolean |
| { |
| return _isNewWindowRegistrationOver; |
| } |
| |
| public static function set isNewWindowRegistrationOver(inputData:Boolean):void |
| { |
| _isNewWindowRegistrationOver = inputData; |
| if(_isNewWindowRegistrationOver) |
| enableApplication(); |
| } |
| } |
| } |
