Writing Mobile Code Essential Software Engineering for Building Mobile Applications [Electronic resources] نسخه متنی

Figure 9.3. Runtime screenshots of the Smartphone emulator running the prime number calculation.

Appendix A, "Additional Resources for the .NET Compact Framework"). The SDK includes the necessary components for Smartphone user interface design as well as a Smartphone emulator that lets you run the applications without needing a physical Smartphone.

Do the following to build and run the application:

When the application is running, you can press the phone button to bring up the Prime Search menu and then press the 1 key to select the Start submenu item. This sets the background search running. As the search runs, the timer1 control should generate a timer event several times a second that triggers the user interface to update the status text displayed on the form. These dynamic updates several times a second keep users informed that progress is being made on their request. The search continues until a prime number is found or the user selects the Abort menu item by selecting the Prime Search menu and pressing 2. To lengthen the time searches take, place a larger number into the text box on the form before starting a search. The number 12345678901234 runs for more than 20 seconds in my emulator. Presently, the following code does not prevent a new search from being started while an old one is still running. A good additional feature to add to the application below would be to check for this condition and to abort an existing search if it were already running. It is also worth looking at the code in Listing 9.5 to see how the lock keyword works to ensure that critical sections of code that are not thread-safe are not entered concurrently by different threads.

Listing 9.4. Code That Goes into the Smartphone Form1.cs class

//----------------------------------------------------
//All this code belongs inside a Form1.cs class
//----------------------------------------------------
//The object that will do our background calculation
FindNextPrimeNumber m_findNextPrimeNumber;
//---------------------------------------------------------
//Update the status text.
//---------------------------------------------------------
void setCalculationStatusText(string text)
{
label1.Text = text;
}
//---------------------------------------------------------
//Menu item for "Exiting" the application
//---------------------------------------------------------
private void menuItemExit_Click(object sender,
System.EventArgs e)
{
this.Close();
}
//---------------------------------------------------------
//Menu item for starting the background calculation
//---------------------------------------------------------
private void menuItemStart_Click(object sender,
System.EventArgs e)
{
//What number do we want to start looking at
long startNumber = System.Convert.ToInt64(textBox1.Text);
//Set up the background calculation
m_findNextPrimeNumber = new FindNextPrimeNumber(startNumber);
//Start the background processing running.
m_findNextPrimeNumber.findNextHighestPrime_Async();
//Set up the timer that will track the calculation
timer1.Interval = 400; //400 ms
timer1.Enabled = true;
}
//---------------------------------------------------------
//Menu item for "Aborting" a calculation under progress
//---------------------------------------------------------
private void menuItemAbort_Click(object sender,
System.EventArgs e)
{
//If we are not doing a calculation, do nothing.
if(m_findNextPrimeNumber == null) return;
//Set the thread up to abort
m_findNextPrimeNumber.setProcessingState(
FindNextPrimeNumber.ProcessingState.requestAbort);
//Let the user instantly know we are getting
//ready to abort...
setCalculationStatusText("Waiting to abort..");
}
//-------------------------------------------------------
//This timer gets called on the UI thread and allows
//us to keep track of progress on our background
//calculation
//-------------------------------------------------------
private void timer1_Tick(object sender, System.EventArgs e)
{
//If we get called and we have no prime number
//we are looking for, turn off the timer
if (m_findNextPrimeNumber == null)
{
timer1.Enabled = false;
return;
}
//--------------------------------------------
//If we've been aborted, throw out the prime seeker
//and turn off the timer
//--------------------------------------------
if (m_findNextPrimeNumber.getProcessingState ==
FindNextPrimeNumber.ProcessingState.aborted)
{
timer1.Enabled = false;
m_findNextPrimeNumber = null;
setCalculationStatusText("Prime search aborted");
return;
}
//--------------------------------------------
//Did we find the right answer?
//--------------------------------------------
if (m_findNextPrimeNumber.getProcessingState ==
FindNextPrimeNumber.ProcessingState.foundPrime)
{
timer1.Enabled = false;
//Show the result
setCalculationStatusText("Found! Next Prime = " +
m_findNextPrimeNumber.getPrime().ToString());
m_findNextPrimeNumber = null;
return;
}
//--------------------------------------------
//The calculation is progressing. Give the
//user an idea of the progress being made.
//--------------------------------------------
//Get the two output values
long numberCalculationsToFar;
long currentItem;
m_findNextPrimeNumber.getExecutionProgressInfo(
out numberCalculationsToFar, out currentItem);
setCalculationStatusText("In progress. Looking at: " +
currentItem.ToString() + ". " +
numberCalculationsToFar.ToString() +
" calculations done for you so far!");
}

Listing 9.5. Code for the FindNextPrimeNumber.cs Class

using System;
public class FindNextPrimeNumber
{
//States we can be in.
public enum ProcessingState
{
notYetStarted,
waitingToStartAsync,
lookingForPrime,
foundPrime,
requestAbort,
aborted
}
long m_startPoint;
long m_NextHighestPrime;
//How many items have been searched?
long m_comparisonsSoFar;
//What is the current item we are doing a prime search for?
long m_CurrentNumberBeingExamined;
//Called to get an update on how the calculation is progressing
public void getExecutionProgressInfo(
out long numberCalculationsSoFar,
out long currentItemBeingLookedAt)
{
//NOTE: We are using this thread lock to make sure that
//we are not reading these values while they are in the
//middle of being written out. Because m_comparisonsSoFar
//and m_CurrentNumberBeingExamined may be
//accessed from multiple threads, any read or write
//operation to them needs to be synchronized with "lock" to
//ensure that reads and writes are "atomic".
lock(this)
{
numberCalculationsSoFar = m_comparisonsSoFar;
currentItemBeingLookedAt = m_CurrentNumberBeingExamined;
}
}
ProcessingState m_processingState;
//--------------------------------------------------
//A very simple state machine.
//--------------------------------------------------
public void setProcessingState(ProcessingState nextState)
{
//--------------------------------------------------
//Some very simple protective code to make sure
//we can't enter another state if we have either
//Successfully finished, or Successfully aborted
//--------------------------------------------------
if   ((m_processingState == ProcessingState.aborted)
||  (m_processingState == ProcessingState.foundPrime))
{
return;
}
//Allow the state change
m_processingState = nextState;
}
public ProcessingState getProcessingState
{
get {return m_processingState;}
}
//---------------------------------------------------
//Returns the prime
//---------------------------------------------------
public long getPrime()
{
if (m_processingState != ProcessingState.foundPrime)
{
throw new Exception("Prime number not calculated yet!");
}
return m_NextHighestPrime;
}
//Class constructor
public FindNextPrimeNumber(long startPoint)
{
setProcessingState(ProcessingState.notYetStarted);
m_startPoint = startPoint;
}
//------------------------------------------------------------
//Creates a new worker thread that will call
// "findNextHighestPrime()"
//------------------------------------------------------------
public void findNextHighestPrime_Async()
{
System.Threading.ThreadStart threadStart;
threadStart =
new System.Threading.ThreadStart(findNextHighestPrime);
System.Threading.Thread newThread;
newThread = new System.Threading.Thread(threadStart);
//Set our processing state to say that we are looking
setProcessingState(ProcessingState.waitingToStartAsync);
newThread.Start();
}
//------------------------------------------------------------
//This is the main worker function. This synchronously starts
//looking for the next prime number and does not exit until
//either:
// (a) The next prime is found
// (b) An external thread to this thread tells us to abort
//------------------------------------------------------------
public void findNextHighestPrime()
{
//If we've been told to abort, don't even start looking
if(m_processingState == ProcessingState.requestAbort)
{
goto finished_looking;
}
//Set our processing state to say that we are looking
setProcessingState(ProcessingState.lookingForPrime);
long currentItem;
//See if it's odd
if ((m_startPoint & 1) == 1)
{
//It's odd, start at the next odd number
currentItem = m_startPoint + 2;
}
else
{
//It's even, start at the next odd number
currentItem = m_startPoint + 1;
}
//Look for the prime item.
while(m_processingState  == ProcessingState.lookingForPrime)
{
//If we found the prime item, return it
if(isItemPrime(currentItem) == true)
{
m_NextHighestPrime =  currentItem;
//Update our state
setProcessingState(ProcessingState.foundPrime);
}
currentItem = currentItem  + 2;
}
finished_looking:
//Exit. At this point we have either been
//Told to abort the search by another thread, or
//we have found and recorded the next highest prime number
//If an abort was requested, note that we have aborted
//the process.
if (m_processingState == ProcessingState.requestAbort)
{
setProcessingState(ProcessingState.aborted);
}
}
//Helper function that looks to see if a specific item
//is a prime number.
private bool isItemPrime(long potentialPrime)
{
//If it's even, it's not prime
if ((potentialPrime & 1) == 0)
{
return false;
}
//We want to look up until just past the square root
//of the item
long end_point_of_search;
end_point_of_search = (long) System.Math.Sqrt(potentialPrime) + 1;
long current_test_item = 3;
while(current_test_item <= end_point_of_search )
{
//---------------------------------
//Check to make sure we have not been asked to abort!
//---------------------------------
if (m_processingState != ProcessingState.lookingForPrime)
{
return false;
}
//If the item is divisible without remainder,
//it is not prime
if(potentialPrime % current_test_item == 0)
{
return false;
}
//advance by two
current_test_item  = current_test_item  + 2;
//------------------------------------------------------
//Up the count of items we have examined
//------------------------------------------------------
//NOTE: We are using this thread lock to make sure that
//we are not reading these values while they are in the
//middle of being written out. Because m_comparisonsSoFar
//and m_CurrentNumberBeingExamined may be
//accessed from multiple threads, any read or write
//operation to them needs to be synchronized with "lock" to
//ensure that reads and writes are "atomic".
lock(this)
{
m_CurrentNumberBeingExamined = potentialPrime;
m_comparisonsSoFar++;
}
}
//The item is prime
return true;
} //End function
} //End class