com.example.sulemaia.Thread

Class ResolverUniformCostThread

java.lang.Object

android.os.AsyncTask<Integer,HeuristicPathTree.Node,HeuristicPathTree>

com.example.sulemaia.Thread.ResolverUniformCostThread

public class ResolverUniformCostThread
extends android.os.AsyncTask<Integer,HeuristicPathTree.Node,HeuristicPathTree>

Class to control all the app flow when the Uniform Cost algorithm is being executed.

Nested Class Summary

Nested classes/interfaces inherited from class android.os.AsyncTask

android.os.AsyncTask.Status

Field Summary

Fields

Modifier and Type	Field and Description
private int	actualStep
private static String	DOWN
private ArrayList<HeuristicPathTree.Node>	expandedNodes
private ArrayList<String>	expansionOrder
private iUniformCost	iMethods
private boolean	isPathFound
private int	lastX
private int	lastY
private static String	LEFT
private HeuristicPathTree.Node[][]	nodes
private static String	RIGHT
private HeuristicPathTree	tree
private static String	UP
private long	updateTime
private HashSet<HeuristicPathTree.Node>	visitedNodes

Fields inherited from class android.os.AsyncTask

SERIAL_EXECUTOR, THREAD_POOL_EXECUTOR

Constructor Summary

Constructors

Constructor and Description
ResolverUniformCostThread(HeuristicPathTree.Node[][] nodes, ArrayList<String> expansionOrder, long updateTime, iUniformCost iMethods) Constructor of the whole resolver for the Uniform Cost Thread.

Method Summary

Modifier and Type	Method and Description
protected HeuristicPathTree	doInBackground(Integer... values) In the background execution of the thread, we are actually executing the main algorithm.
private HeuristicPathTree.Node	expandInDirection(String direction, int y, int x, HashSet<HeuristicPathTree.Node> visitedNodes) check if the direction in which the node is trying to be expanded is available or has any limitations.
private void	getNodesNextStep(HeuristicPathTree.Node node, ArrayList<HeuristicPathTree.Node> expandedNodes, HashSet<HeuristicPathTree.Node> visitedNodes) Expand the nodes correctly, according to the limitations of the map.
protected void	onPostExecute(HeuristicPathTree heuristicPathTree) Whenever the algorithm finishes, we have to finish the thread.
protected void	onProgressUpdate(HeuristicPathTree.Node... values) Every time the thread refreshes, we have to move the character in the UI.
private void	setFitness(HeuristicPathTree.Node response, HeuristicPathTree.Node Father) Fitness method so we know which node to select each time.

Methods inherited from class android.os.AsyncTask

cancel, execute, execute, executeOnExecutor, get, get, getStatus, isCancelled, onCancelled, onCancelled, onPreExecute, publishProgress

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DOWN

private static final String DOWN

See Also:

Constant Field Values

UP

private static final String UP

See Also:

Constant Field Values

LEFT

private static final String LEFT

See Also:

Constant Field Values

RIGHT

private static final String RIGHT

See Also:

Constant Field Values

expandedNodes

private ArrayList<HeuristicPathTree.Node> expandedNodes

visitedNodes

private HashSet<HeuristicPathTree.Node> visitedNodes

nodes

private HeuristicPathTree.Node[][] nodes

isPathFound

private boolean isPathFound

iMethods

private iUniformCost iMethods

updateTime

private long updateTime

expansionOrder

private ArrayList<String> expansionOrder

tree

private HeuristicPathTree tree

lastY

private int lastY

lastX

private int lastX

actualStep

private int actualStep

Constructor Detail

ResolverUniformCostThread

public ResolverUniformCostThread(HeuristicPathTree.Node[][] nodes,
                                 ArrayList<String> expansionOrder,
                                 long updateTime,
                                 iUniformCost iMethods)

Constructor of the whole resolver for the Uniform Cost Thread.

Parameters:

nodes - Heuristic nodes.

expansionOrder - Expansion order set by the user.

updateTime - Update time for the thread.

iMethods - Method, related to which algorithm is being used.

Method Detail

doInBackground

protected HeuristicPathTree doInBackground(Integer... values)

In the background execution of the thread, we are actually executing the main algorithm.

Specified by:

doInBackground in class android.os.AsyncTask<Integer,HeuristicPathTree.Node,HeuristicPathTree>

Parameters:

values - Values related to the initial and final coordinates.

Returns:

Either the tree or null value.

onProgressUpdate

protected void onProgressUpdate(HeuristicPathTree.Node... values)

Every time the thread refreshes, we have to move the character in the UI.

Overrides:

onProgressUpdate in class android.os.AsyncTask<Integer,HeuristicPathTree.Node,HeuristicPathTree>

Parameters:

values - Values related to the position of the character.

onPostExecute

protected void onPostExecute(HeuristicPathTree heuristicPathTree)

Whenever the algorithm finishes, we have to finish the thread.

Overrides:

onPostExecute in class android.os.AsyncTask<Integer,HeuristicPathTree.Node,HeuristicPathTree>

Parameters:

heuristicPathTree - Tree to process.

getNodesNextStep

private void getNodesNextStep(HeuristicPathTree.Node node,
                              ArrayList<HeuristicPathTree.Node> expandedNodes,
                              HashSet<HeuristicPathTree.Node> visitedNodes)

Expand the nodes correctly, according to the limitations of the map.

Parameters:

node - Node to be processed.

expandedNodes - Expanded nodes list so we dont repeat.

visitedNodes - Visited nodes list so we dont repeat.

setFitness

private void setFitness(HeuristicPathTree.Node response,
                        HeuristicPathTree.Node Father)

Fitness method so we know which node to select each time.

Parameters:

response - Node to process.

expandInDirection

private HeuristicPathTree.Node expandInDirection(String direction,
                                                 int y,
                                                 int x,
                                                 HashSet<HeuristicPathTree.Node> visitedNodes)

check if the direction in which the node is trying to be expanded is available or has any limitations.

Parameters:

direction - Direction to be expanded.

y - Y coordinate of the actual node.

x - X coordinate of the actual node.

visitedNodes - Visited nodes list so we dont repeat.

Returns:

a null value and/or the next coordinate to process.