DOWNLOAD HERE

08 Jul DOWNLOAD HERE

Running head: Project: Developing an Android Weather Application for RightClick 1

Project: Developing an Android Weather Application for the RightClick 47

Project: Developing an Android Weather Application for RightClick Company

Name

Institution

Date

Developing an Android Weather Application for RightClick Company

Introduction

Weather is one of the most crucial factors in the current world. It matters a lot because it has the ability to interrupt the daily human activities whether political, social or economic according to Sunburst Communications & Weather Channel (1997). As such, there is an immense need that it is taken into consideration when planning for any project, practice or transaction. While this need is compulsory, there has been a great difficulty in considering the weather as much of its elements like heavy rainfall comes from the sky, which man knows very little about. However, with the advanced technology and particularly the contemporary society, humans, from their creativity, managed to come up with a way of predicting the weather patterns (United States., & United States, 2001). The strength and ability of this way lie in software, which man created to check on various elements of weather. Today, there are a lot of applications both for the desktops and phones, which use different mechanisms to predict the weather (Sunburst Communications & Weather Channel, 1997). Some apps measure the amount of moisture in the air to determine the temperature of a place. Others measure the intensity of the sun rays to determine the same element, which in turn, in both cases, is used to determine rainfall and its intensity.

There are a million weather apps in use already. Nonetheless, only a few of them work as anticipated by the developers and the users. The majority of the others have a tendency of ‘stopping to respond’ to the users’ commands, while others are faulty, hence gives unauthentic results (Vonder, et, al, 2004). For instance, an app’s result may suggest a period of heavy rainfall, (El Nino) but come that period, everything is either normal or there is a drought spell instead. Other software(s) are device unfriendly as they cause the overheating of the devices they are installed in like phones and tablets. Some are even vulnerable to malware and virus attacks, according to Zhou & Weijnen, (2015), particularly those that use data for connection and operation. Users have as well been raising concerns of late about several of the apps being costly. This grievance has been in line with their initial cost of acquisition and maintenance, which includes the update data and that for connection. In a simpler sense, the majority of them are expensive and consume a lot of data while running. Other than causing the overheating of phones, some of them as well consume a lot of power.

Considering these issues, this paper is a project that aims at developing an android weather application for RightClick Company using SDLC methodology for public safety. RightClick Company is an innovative IT recruiting and staffing firm. One of its endeavors is organizing usual social events to make sure that people get together regularly. This application will benefit both the workers of RightClick and its clients. The workers, especially the planners and organizers of such events will be able to tell the appropriate time to schedules the social events, for example, so as to avoid inconveniences. The clients, on the other hand, will as well be able to know the attire, weather heavy or light as a result of impending rainfall or cold spells or warm spells respectively.

The app will rely on measuring some aspects like heat and moisture in the atmosphere thereby drawing the insights of the likely impending weather, whether it will rain, and by what intensity, whether there will be the sun and high temperature, and by what intensity just to mention a few factors.

We are optimistic that at the end of this project, we will have an application, which will be capable of authentically performing its duty, which is, forecast weather and that would see off the majority of the weaknesses of the already existing weather app if not all. WFJ will be efficient, far from ‘hanging,’ that is, failing to respond to commands, cost efficient and secure among others. In that connection, as a developer, the article is very keen to follow the appropriate steps to the latter, use the correct tools and mechanisms and apply the appropriate methodology.

Methodology (SDLC)

There are various methodologies in existence, which are used to develop software(s). However, due to several factors, the Software Development Life Cycle (SDLC) method has yielded successful application of late (Argonne National Lab., United States., United States., & Michalakes, 2011). Following the reason, the majority of software designing and programming specialists have recommended SDLC for the creation of the predominance of applications both the web or desktop and mobile based (Purba & Shah, 2000). This method, SDLC as writes Baldwin & Bordoli, (2014) refers to the whole procedure of prescribed, rational steps executed to develop an application, whether android or PC.

Mobile Development SDLC (The Waterfall Model)

The SDLC is comprised of various methods. Practically, Lewis, (2012) explicates that it is made up of six methodologies, which can either be used independently or combined for fine results. These methods are; the Waterfall Model, the V-Shaped Model, the Iterative Model, the Spiral Model, the Big Bang Model and the Agile Model (Argonne National Lab., United States., United States., & Michalakes, 2011). This project will hugely use the Waterfall model.

Other than being the initial and so stable methodology of SDLC, the Waterfall Model is very straightforward of all the structured methodologies of SDLC. It is as simple as finishing one process and step, before pursuing the next one.

The Waterfall mobile or android software development sequence does not differ to a great extent to that of the desktop or web apps. Similar to those, the android software development sequence as well is made up of five major parts and processes, which will be crucial in creating our app in this project. These processes and phases are; Inception, Design, Development, Stabilization and Deployment.

The SDLC and the Waterfall Model are the perfect methodology and models for this project because of several factors. One thing is that they suit the experimentation and adjustment nature of the android software (Birze, 2013). Mobile software befalls much success after a lot of experimentations and adaptations. SDLC as well enhances consistency and pilots to continued use of the software. Besides, as writes Shah, & Rahman, (2013), SDLC frameworks naturally extend into the mobile software update model and also enable the apps to be able to respond to the technological adjustments.

The Required Tools

With the right methodology and model but without the appropriate tools, there is no application that can be created. For this weather android software development project, the following are the main tools that will be used; the Eclipse ADT Bundle, the OpenWeatherMap API Key, and the Icons. The Eclipse ADT bundle will be downloaded from the Android Developer website. For the icons: the weather icons font designed by Erik Flowers will be used.

In addition, the TIF file will also be required. It will be downloaded from the internet via the search engines. Depending on the weather conditions, fonts will be used to render various icons.

Literature Review

From the last century, technological advancements have turned the world into a totally different thing when it comes to efficiency and speed. Today, almost every aspect of life is operated either partly or fully on a digital (technological) platform. It is amazing that even the natural forces like earthquakes, heavy rainfall, and dry spells are contemporarily managed digitally and can be predicted. In one way or the other, the software development and programming knowledge have a huge part to do with these advancements (Sunburst Communications & Weather Channel, 1997). While business and other apps have complex histories, the first weather advisory software developed just a moment after the idea of weather forecasting hit the headlines. Before, the weather scientists used such instruments as the barometers to determine the state of the atmosphere hence weather. Practically, weather forecasts were made by gathering quantitative data regarding the present state of the atmosphere of a particular region and use the scientific concept of the atmospheric processes to scheme how the atmosphere will change.

The real efforts of software weather forecasting, popular as numerical weather prediction came in 1920 by Lewis Fry Richardson. However, it was until in the 1950s, during the computer simulation age, when ENIAC was executed to develop the first weather forecasts through a computer based on a highly abridged approximation to the atmospheric principal equations that it started to realize realistic results. Today, as posits United States (2011), there are several of both the global and regional forecast models in operation in various parts of nations worldwide, using the contemporary weather observations relayed from weather satellites, radiosondes and other observing systems as inputs.

As we speak, there are more than a million weather advisory apps, both for mobile and computer devices. Nonetheless, the majority of them are far from being realistic and authentic. Other than failing to give reliable statistics, hence predictions, some of them are as well unable to adapt to the atmospheric changes and shifts, due to the use of outdated technology while developing them.

Proposal

This project aims at developing a ‘weather advisory software’ that will overcome these weaknesses because without overcoming them, there is not much that the world can do. Consider that weather has full potential or destroying every plan and project of mankind. For instance, poor timing of a construction of a storey building may result into the premise being brought down by heavy rainfall, which may come as a result of either luck or poor forecast. Authenticity and accuracy are just a few of the factors, which a proper weather application should ensure they are well taken care of. In this project, these are the priorities as they are what make a weather software logical and useful. Other things like being not only responsive but timely responsive to the users’ commands, cost effectiveness that is, in terms of power and data usage and adaptability are benefits that will just follow as supplements. This is a massive project that is worth all the positive support because, by the end of the day, it is going to remedy numerous factors and perceptions about weather forecasting and make out a new positive trend for the world.

Iterations

Typically, this project is supposed to have five iterations namely Inception, Design, Development, Stabilization and Deployment. However, Stabilization will be fused with deployment due to space and time factors. As such, the functional iterations for this project are Inception, Design, Development, and Stabilization and Deployment.

Iteration 1: Inception

In the inception phase, the project will highlight its idea, which will form the foundation of the software to be created. The idea here, as already stated, is a way to forecast the weather and initiate a weather advisory mechanism. As such, all the activities that will come up afterward will be directed towards putting this idea into action. This phase will form a solid basis for the software.

However, all these activities will follow a comprehensive study of the how android or mobile applications are developed and how they operate from the background. This information will be crucial to creating an own application, which will be weather oriented. The main goal here is to explore the project and understand its mission and develop an idea, which will see that mission accomplished.

Iteration 2: Design

After developing the idea, the next thing will be to come up with a framework of the idea. This act will happen in this phase. The project will define the User Experience (UX) of the software in creation. This act will include such activities like explicating the general layout and its working ways or mechanism among others and also turning the UX into a proper UI (User Interface) design. In accomplishing this task, the project will seek the duties of a graphic designer.

Given that I would have gathered enough knowledge in the inception iteration, I do not do not expect coming up with the project idea’s design will be any big deal. I will use the knowledge to get the SDLC methodology in a functioning mode and combine the appropriate tools and element to see that at the end of the iteration, there is a good design.

Iteration 3: Development

Development is mainly the major part of the software building process. It is the most resource intensive stage, as it is the phase in which the actual building of the software occurs. This project will be looking to have a complete app after this phase. With the app design already in place in addition to a massive knowledge of developing an app, this process will be a piece of chocolate

Iteration 4: Stabilization and Deployment

After the app has been developed, it will be tested in the Stabilization phase. At this point, the development will be quite enough and so question and answer will be crucial to test the application, where such things like bugs will be fixed. Nonetheless, though it is necessary, the project will not take its application in a limited beta phase in this stage, where the audience will be given an opportunity to test the software and offer feedback and changes.

The deployment phase is essentially the last phase. In this project, it will entail the finalization of the UI. New features will also be added to the new version of the software in this phase.

Iteration 1:

Inception (Preparation of the Project)

Plan

The aim of this stage is to lay down a foundation on which the entire project will operate from. It is as well this face that commences the project. Our idea is to come up with a weather advisory application. This stage entails the collection of all the relevant tools and software required for the purpose. Knowledge is one of these crucial tools. We will need to know how to create software and mobile software on one side and then specialize it so that it concentrates on the aspect of weather on the other side. The Android organization offers various tutorials on app building, especially the ones for phones and tablets (O’Rourke, 2012). As such, the project will borrow some of the knowledge and skills from this organization by revising these tutorials, which will be downloaded from its website.

Other than this knowledge, mastering the mechanism behind the functioning of the SDLC methodology and its Waterfall model is also crucial. Although its basics can be as well found on the website of the android organization, it can also be found elsewhere on the internet. This project, other than relying on the Android organization will as well seek to diversify its knowledge and understanding of the working principles of the methodology by revising various different sources. The search engines, and especially Google will be crucial in bringing on board these sources.

Plans will also be put in place here to ensure that the project will have access to and the understanding of the appropriate basic goals, values, ethics and the policies which are to be observed by the Basic application developer. I will also use this phase to countercheck if we have all the required tools and mechanisms for the development of the application. My goal in this research is to develop a standard android weather application for RightClick organization.

Action

This phase will be practical and I expect it to take me two days. It is in this phase that I will visit the android organization website and download the tutorials. As such, I will be out to know how applications and especially those for the phones and tablets are developed. I will use the Google search engine to identify the suitable articles with the appropriate directions on the functioning of the SDLC methodology and its Waterfall model. What will follow next is the review of the sources so that we are familiar with all its basics principles, hence capable of applying it to use in the development iteration.

This part will as well see me go on the ground to know what guidelines, goals, values and ethics govern the software production sector. I will use the Android organization. I will check on its website to see what the minimum requirements are, especially in terms of quality and quality. I will also practically download all the perquisites of the project in this phase. I will acquire the Eclipse ADT Bundle from the Android Developer website. The OpenWeatherMap API Key is free on the internet and so I will be free. I will obtain one by signing up at the OpenWeatherMap website. The recommended icons for such projects are those that were created by Erik Flowers. I will obtain them from the internet via the Google search engine. I will also need to use the TTF file as I will require using it in the native app. I will also download this file from internet through the Google search engine. The fonts are as well a crucial requisite in this project. They will be used to render various icons depending on the weather conditions. I will download and use the samples from the Android organization.

Observation

By this phase, I was ready to go as I had gathered everything that it takes. My preparation activity was successful. The Android organization was so crucial in making possible this act. Its website provided me with all that I wanted from it. For instance, the Eclipse ADT Bundle was readily available and its download was already enabled by the website’s system. When I got into the website and specified my request as the development of an android app, I found all the tools for the task listed in one of the tutorials named ‘how to create an android app for phones and tablets.’ They were already powered with a download command with the download button appearing under each of the files and tools. All I was expected to do was identify what I wanted and then click on download to obtain them.

Yet I had expected to obtain other files from the internet, apart from the SDLC methodology’s basic concepts, I got everything that could see me go in developing my own app from this Android organization’s platform. By the end of activity phase, I had everything. I had the knowledge on developing an app and that on the methodology to use, the SDLC and especially the Waterfall model. I also had all the tools to necessary to start and complete the project. I had downloaded the Eclipse Bundle, The OpenWeatherMap API Key, the weather icons, the TIF file and the image editor.

Reflection

By this phase, I had completed everything that I made in my plan as part of my project successful and on time. The activity was crucial to my project as by now I have a very good and enough knowledge on how to develop an application and especially that one designed for the phones and other mobile gadgets like tablets. I now got knowledge on the basic application process, which is crucial to the development of my project. For a case in point, I now know which part ought to come first and which one to follow in a successive run and which one will come last. I am at the moment also aware of the parts that I can do better and that one that I cannot in this project. For this reason, I know where to concentrate very much, taking enough time for better results and where to minimize time.

Given these reasons, my inception iteration came out successful. It is worth saying that I got everything that was crucial to seeing me develop and complete my weather application. However, there were areas where I needed clarification from other sources. The working mechanism of the SDLC methodology and its Waterfall model is a clinical example in this case, as supports Parikh, (2008). I really failed to understand its architecture and how it is applied by both the tutorial from the Google search engine and from the Android organization’s website. I had to go back to my lecture notes to be able to understand this part. It was after this U-turn that I was able to visualize anything to do with SDLC, hence apply it to an app development process. I was worried and nervous before, but after mastering this concept, I was confident once again as I knew I had all that it could cost to make my app.

Iteration 2: Design:

(The Framework of the Weather App)

The design inception, in this project, is about the software architecture and the software design of my application. What is going to be the software design and architecture of this app?

Plan

Software design refers to the process of creating a specification of a software artifact, expected to meet the set objectives, with the use of primitive subjects and apparatus constraints as writes Baldwin & Bordoli, (2014). In that connection, here I seek to create this specification of my weather application. Since software design refers to either ‘everything entailed in framing, conceptualizing, commissioning, implementing, and eventually modifying complex systems’ or “the practice subsequent to the requirements specification and prior to programming, like for the case of a stylized software engineering process I am will check out information on these practices on the internet via Google for information on what could suit my app.

Jolliffe, & Stephenson, (2012) holds out that software architecture, on the other hand, refers to a software system’s primary structures and the branch of establishing such structures together with credentials of these structures. Developers anticipate these structures to reason apropos the software system. Every structure is made up of the software components, the relations among them as well as the properties of the relations and the elements alike, alongside underlying principle for the introduction and configuration of every component.

While the software design and structure will also be crucial in my project, much of their establishment actions will occur in the background, hence are not actually huge parts of this project. In fact, I will just use some the software design and architecture of android as they are available on their website. All the same, I will develop the design for the entire project in this phase. I will work on this task, which I anticipate that it takes three days.

Action

In this phase, I am going to decide and reveal the design of my application. I will weigh up various factors to determine the software design and architecture, which will see my weather application, operate efficiently with very little malfunctions. One thing I will focus on is diversity. Since I want my software to be compatible with the majority of if not all the phones and tablets, I will have to choose a design that will enable it to achieve this factor. Yet, since I already identified the android software design and architecture, my task is simple here. I will just visit the android website and use its features.

Software architecture entails making elemental structural selections that are costly to change once put into practice (Iversen & Eierman, 2014). Selections in software architecture also referred to as architectural decisions, comprises of specific structural alternatives from the prospects in the software design. For a case in point, the systems which controlled the space shuttle launch device had the specification of being very reliable and speedy. As such, a suitable real-time computing language would be required for selection. In addition, to gratify the reliability specifications the selection could be executed to have manifold superfluous and autonomously produced replicas of the program, and to run the replicas on sovereign hardware while cross-checking results.

With focus on my project, although I will use the Android organization’s software architecture and design’s features, I will research on the internet on how the above information and tasks apply to my project, so that I use them to enhance my software’s design and architecture and even make them better than those of Android.

In my weather app design weather will be the main component with the location, condition, atmosphere, forecast and units components all looking upon it. The design will look like this

Observation

I accessed the Android organization website and I was really impressed with what I found out regarding the software design and the software architecture. Other than just offering me with the most appropriate software design and software architecture that I could use the site as well was rich of information and processes on how to frame, conceptualize, commission, implement and as well as to manage complex systems.

I managed to put everything right as far as the task of this phase was concerned. However, there were points where I had to make adjustments for the suitability of my app. The android organization on its website, for example, did not specify the software design and the software architecture, which it offered. They were general and could suit any application depending on the adjustments, which it would be exposed to. Due to my knowledge capacity in this field, I did not subject the design and architecture to any changes but just mastered and kept them the way they were. I hoped research on how to make the adjustments on them later if there could arise a serious need to alter them.

Meanwhile, developing my app’s structure, another implication for design was not much of a problem. According to Purba & Shah, (2000), an app’s design is typically an impression of how an app will look like and possibly how it will be structured and will operate. With this background knowledge, I managed to figure out a skeleton of my weather software as well as its functioning mechanism.

Reflection

This task was another good one for my experience and development in software development, but a bulk one too and exhausting both to the body and the brain. Though it was time-consuming as well, I managed to make up my design and within my time frame.

While the software design and the software architecture are recommended to be constantly used in application developments (Wagner, 2011), I thought either none or maybe only one of them could do for my weather application. I did not see any special thing about them because I had to a lot of adjustments on them in my general design for my weather app until I ended up like without them. Perhaps I should have bothered about them but could have just gone straight to the point of thinking of how I would like my software to look like and operate, check n some few examples on the internet and eventually formulate mine. Still, I would have ended up with the framework like on the figure above because my idea would not have been any different. However, I would have saved on time and other resources, which I otherwise wasted while using the software design and the software architecture. According to Zhou & Weijnen, (2015), these components are only crucial when developing such crucial and complex software like those, which operates the ATM machines. As such, they were not of that great importance, but simply destructive to me in this project. Next time, depending on which software I will be developing, I will exclude them.

All the same, I came out successful and in the course of the phase, I had completed the second step in my project; Design. Before this phase, I had all the tools and methodologies for my project. Now, I have gone a step ahead and made a design for my project. I am now set to begin developing my weather up and this is the stage that follows; Development.

Iteration 3:

Development (Creating the App)

Plan

In this phase, I plan to make the first practical approach of developing my app. By this point, at least it should be seen that there is something in the making. I am going to create a new app project here. I will then add the Custom Font and edit the manifest after naming the activity. I will then edit the activity’s layout before I Edit the Fragment’s Layout and the string xml. Thereafter, I will add the activity menu and then fetch the data probably from the From OpenWeatherMap. My next action will be storing the city as a preference followed by Creating the Fragment and finally editing the activity.

Give and before the above activities, I plan to be ready for everything so that when I commence the development project, I do not stop anywhere because of a missing factor. As such, I plan to install all the plug-in and tools. I will start with installing JAVA. The JAVA will be my main scripting language of the app. It will help me save time and implement the java flow diagrams, which will in turn make it easy to understand the coding techniques. Besides, what should be the output can be easily planned from this tool. Again, I am the technician to take the entire job here. I do not intent to take more than 5 days here.

Action

1. Creating a New Project

I will call my app SimpleWeatherJet (SWJ). I will enter a unique package name. I will set the minimum obligatory SDK to Android 2.2, and then the target SDK to Android 4.4. I will leave the theme at Holo Dark.

Fig. 1.0

This software will only have a single Activity. As such, it will be based on a blank act template as highlighted in the following figure, Fig. 1.1

I will name the Activity WeatherActivity. I will be using a Fragment within this Activity. My layout, which is related to the Activity is activity_weather.xml. On the other hand, my layout linked to the Fragment is fragment_weather.xml.

3. Adding the Custom Font

In this step, I will copy the weathericons-regular-webfont.ttf to the assets or fonts directory of my project. I will the rename it weather.ttf.

4. Editing the Manifest

This software needs only a single permission. It only needs the android.permission.INTERNET.

1<uses-permission android:name=”android.permission.INTERNET”/>

For the sake of keeping my project simple, I will only support the portrait mode. My project’s manifest’s activity node ought to appear like this:

01 <activity

02 android:name=”ah.hathi.simpleweatherJet.WeatherActivity”

03android:label=”@string/app_name”

04 android:screenOrientation=”portrait”>

05 <intent-filter>

06 <action android:name=”android.intent.action.MAIN” />

07 <category android:name=”android.intent.category.LAUNCHER” />

08 </intent-filter>

09 </activity>

5. Editing the layout of the Activity

The activity_weather.xml ought to already have frame layout, as such, I will have no much to edit as far as it is concerned. Nonetheless, I will add some extra component to modify its background to #FF0099CC.

1<FrameLayout xmlns:android=”http://schemas.android.com/apk/res/android”

2 xmlns:tools=”http://schemas.android.com/tools”

3 android:id=”@+id/container”

4 android:layout_width=”match_parent”

5 android:layout_height=”match_parent”

6 tools:context=”ah.hathi.simpleweather.WeatherActivity”

7 tools:ignore=”MergeRootFrame”

8 android:background=”#FF0099CC” />

6. Editing the layout of the Fragment

The fragment_weather.xml is supposed to show the following information:

· The country and the city

· The Present temperature

· An icon exhibiting the present condition of the weather

· A timestamp informing the users the last update date and time of the weather condition and

· A more comprehensive information regarding the existing weather, for instance humidity and description

Given this point, I will edit the fragment_weather.xml by adding up approximately 5 TextView tags so that it is capable of exhibiting the above data.

Since the text views need to appear in an orderly manner, I will use the RelativeLayout to arrange them so as to achieve this goal. And for diversity, I will adjust the sizes of the texts so that my app suits a great array of devices.

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 5

<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android” xmlns:tools=”http://schemas.android.com/tools” android:layout_width=”match_parent” android:layout_height=”match_parent” android:paddingBottom=”@dimen/activity_vertical_margin” android:paddingLeft=”@dimen/activity_horizontal_margin” android:paddingRight=”@dimen/activity_horizontal_margin” android:paddingTop=”@dimen/activity_vertical_margin” tools:context=”ah.hathi.simpleweather.WeatherActivity$PlaceholderFragment” >   <TextView android:id=”@+id/city_field” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_alignParentTop=”true” android:layout_centerHorizontal=”true” android:textAppearance=”?android:attr/textAppearanceLarge” />   <TextView android:id=”@+id/updated_field” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_below=”@+id/city_field” android:layout_centerHorizontal=”true” android:textAppearance=”?android:attr/textAppearanceMedium” android:textSize=”13sp” />   <TextView android:id=”@+id/weather_icon” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_centerVertical=”true” android:layout_centerHorizontal=”true” android:textAppearance=”?android:attr/textAppearanceLarge” android:textSize=”70sp” />   <TextView android:id=”@+id/current_temperature_field” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_alignParentBottom=”true” android:layout_centerHorizontal=”true” android:textAppearance=”?android:attr/textAppearanceLarge” android:textSize=”40sp” />   <TextView android:id=”@+id/details_field” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_below=”@+id/weather_icon” android:layout_centerHorizontal=”true” android:textAppearance=”?android:attr/textAppearanceMedium” />   </RelativeLayout>

7. Editing the strings.xml

This file incorporates the strings used in my software. It as well contains the Unicode character codes, according to Nudelman, (2013), which I will execute to render the weather icons in the project. At this point, my software will be capable of offering direction and prediction on only eight different types of weather conditions. Nonetheless, I want and would love my app to deal with and handle of the weather elements. As such, I will make adjustments and would add the following files to the values/strings.xml:

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22

<?xml version=”1.0″ encoding=”utf-8″?> <resources>   <string name=”app_name”>Simple Weather</string> <string name=”change_city”>Change city</string>   <!– Put your own APP ID here –> <string name=”open_weather_maps_app_id”>11111</string>   <string name=”weather_sunny”>&#xf00d;</string> <string name=”weather_clear_night”>&#xf02e;</string>   <string name=”weather_foggy”>&#xf014;</string> <string name=”weather_cloudy”>&#xf013;</string> <string name=”weather_rainy”>&#xf019;</string> <string name=”weather_snowy”>&#xf01b;</string> <string name=”weather_thunder”>&#xf01e;</string> <string name=”weather_drizzle”>&#xf01c;</string>   <string name=”place_not_found”>Sorry, no weather data found.</string>   </resources>

8. Adding a Menu Item

My app has to be able to allow the users to choose the city or region whose weather they want to check and know. To enable this factor, I will edit my menu/weather.xml and include some items for this alternative.

01 02 03 04 05 06 07 08 09 10 11 12

<menu xmlns:android=”http://schemas.android.com/apk/res/android” xmlns:app=”http://schemas.android.com/apk/res-auto” xmlns:tools=”http://schemas.android.com/tools” tools:context=”ah.hathi.simpleweather.WeatherActivity” >   <item android:id=”@+id/change_city” android:orderInCategory=”1″ android:title=”@string/change_city” app:showAsAction=”never”/>   </menu>

Now that all the XML files are ready to use, let’s move on and query the OpenWeatherMap API to fetch weather data.

9. Fetching Data from OpenWeatherMap

I will get the existing weather details of any region or city formatted as JSON with the help of the OpenWeatherMap API. In the query string, I will pass the metric system the results ought to be in and the name of the city.

Just for a case in point, to obtain the present weather info for Canberra, with the use of the metric system, I will sent a request to http://api.openweathermap.org/data/2.5/weather?q=Canberra&units=metric

The response I will expect to get back from the API should look like below:

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

{ “base”: “cmc stations”, “clouds”: { “all”: 90 }, “cod”: 200, “coord”: { “lat”: -35.28, “lon”: 149.13 }, “dt”: 1404390600, “id”: 2172517, “main”: { “humidity”: 100, “pressure”: 1023, “temp”: -1, “temp_max”: -1, “temp_min”: -1 }, “name”: “Canberra”, “sys”: { “country”: “AU”, “message”: 0.313, “sunrise”: 1404335563, “sunset”: 1404370965 }, “weather”: [ { “description”: “overcast clouds”, “icon”: “04n”, “id”: 804, “main”: “Clouds” } ], “wind”: { “deg”: 305.004, “speed”: 1.07 } }

I will create a new Java name and class. I will name it RemoteFetch.java. This class will be in charge of fetching the weather information from the OpenWeatherMap API. I will use the HttpURLConnection class to place the remote request. The OpenWeatherMap API anticipates the API key in a header of HTTP demarcated x-api-key. This element will be specified in my request with the use of the setRequestProperty method.

I will use the BufferedReader tool to decode the response of the API into a StringBuffer. When I will get a complete response, I will cover it to a JSONObject object.

As evident in the above sample response, the JSON data have a field named cod. It has got a value of 200 in case the request comes out successful. I will use this value to test out whether the JSON response has the recent weather data or not.

I will expect the RemoteFetch.java class to appear like this:

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23

package ah.hathi.simpleweather;   import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL;   import org.json.JSONObject;   import android.content.Context; import android.util.Log;   public class RemoteFetch {   private static final String OPEN_WEATHER_MAP_API = “http://api.openweathermap.org/data/2.5/weather?q=%s&units=metric“;   public static JSONObject getJSON(Context context, String city){ try { URL url = new URL(String.format(OPEN_WEATHER_MAP_API, city)); HttpURLConnection connection = (HttpURLConnection)url.openConnection();   connection.addRequestProperty(“x-api-key”, context.getString(R.string.open_weather_maps_app_id));   BufferedReader reader = new BufferedReader( new InputStreamReader(connection.getInputStream()));   StringBuffer json = new StringBuffer(1024); String tmp=””; while((tmp=reader.readLine())!=null) json.append(tmp).append(“\n”); reader.close();   JSONObject data = new JSONObject(json.toString());   // This value will be 404 if the request was not // successful if(data.getInt(“cod”) != 200){ return null; }   return data; }catch(Exception e){ return null; } } }

10. Store the City as a Preference

I do not expect the users to spell out the name of the city or region all the time they want to use the software. I want the application to be capable of remembering the last city and or the exact region that the user checked in. I will achieve this factor by putting the SharedPreferences to use. Nonetheless, in the place of accessing the preferences directly from my Activity class, it is better to build a distinct class for this idea

I will establish another Java class and call it CityPreference.java. I will as well create two methodologies getCity and setCityTo to store and get back the name of the city. The SharedPreferences entity is initialized in the constructor. On the other hand, the CityPreference.java class ought to appear as follows;

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

package ah.hathi.simpleweather;   import android.app.Activity; import android.content.SharedPreferences;   public class CityPreference {   SharedPreferences prefs;   public CityPreference(Activity activity){ prefs = activity.getPreferences(Activity.MODE_PRIVATE); }   // If the user has not chosen a city yet, return // Sydney as the default city String getCity(){ return prefs.getString(“city”, “Sydney, AU”); }   void setCity(String city){ prefs.edit().putString(“city”, city).commit(); }   }

11. Creating the Fragment

I will develop a new Java class. I will call it WeatherFragment.java. This fragment is connected to the fragment_weather.xml in that it uses its layout. I will declare the 5 TextView items and initialize them in the onCreateView methodolody. I will afterwards declare a new Typeface entity called weatherFont. This TypeFace item will point to the web font that I downloaded and kept in the assets/fonts folder.

I will be utilizing distinct Thread to asynchronously obtain data from the OpenWeatherMap API. I will not be able to keep posted the user interface a background thread like this one. Given this point, I will require a Handler item that I will initialize in the constructor of the WeatherFragment class.

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19

public class WeatherFragment extends Fragment { Typeface weatherFont;   TextView cityField; TextView updatedField; TextView detailsField; TextView currentTemperatureField; TextView weatherIcon;   Handler handler;   public WeatherFragment(){ handler = new Handler(); }   @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_weather, container, false); cityField = (TextView)rootView.findViewById(R.id.city_field); updatedField = (TextView)rootView.findViewById(R.id.updated_field); detailsField = (TextView)rootView.findViewById(R.id.details_field); currentTemperatureField = (TextView)rootView.findViewById(R.id.current_temperature_field); weatherIcon = (TextView)rootView.findViewById(R.id.weather_icon);   weatherIcon.setTypeface(weatherFont); return rootView; } }

Through calling the createFromAsset on the Typeface class, I will initialize the weatherFont item. I will as well invoke the updateWeatherData scheme in the onCreate.

1 2 3 4 5 6

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); weatherFont = Typeface.createFromAsset(getActivity().getAssets(), “fonts/weather.ttf”); updateWeatherData(new CityPreference(getActivity()).getCity()); }

I will then start a new thread in updateWeatherData, which on the RemoteFetch class, I will name getJSON. Here, in case the getJSON returns a value, which is null, I will program my software so that it displays an error notification to the users. In case it does not, then I will bring into play the renderWeather methodology.

It is only the main thread that is permitted to update the user interface of an Android application. RenderWeather or Calling Toast from the background thread just directly would lead to a runtime error. This reason explains why I will need to call these mechanisms using the handler’s post method.

01 02 03 04 05 06 07 08 09 10

private void updateWeatherData(final String city){ new Thread(){ public void run(){ final JSONObject json = RemoteFetch.getJSON(getActivity(), city); if(json == null){ handler.post(new Runnable(){ public void run(){ Toast.makeText(getActivity(), getActivity().getString(R.string.place_not_found), Toast.LENGTH_LONG).show(); } }); } else { handler.post(new Runnable(){ public void run(){ renderWeather(json); } }); } } }.start(); }

The renderWeather methodology implements the JSON data in the updating process of the TextView items. The weather node of the JSON reaction is an array of data. In this project, I will only be making use of the foremost aspect of the array of the weather info.

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 2

private void renderWeather(JSONObject json){ try { cityField.setText(json.getString(“name”).toUpperCase(Locale.US) + “, ” + json.getJSONObject(“sys”).getString(“country”));   JSONObject details = json.getJSONArray(“weather”).getJSONObject(0); JSONObject main = json.getJSONObject(“main”); detailsField.setText( details.getString(“description”).toUpperCase(Locale.US) + “\n” + “Humidity: ” + main.getString(“humidity”) + “%” + “\n” + “Pressure: ” + main.getString(“pressure”) + ” hPa”);   currentTemperatureField.setText( String.format(“%.2f”, main.getDouble(“temp”))+ ” ℃”);   DateFormat df = DateFormat.getDateTimeInstance(); String updatedOn = df.format(new Date(json.getLong(“dt”)*1000)); updatedField.setText(“Last update: ” + updatedOn);   setWeatherIcon(details.getInt(“id”), json.getJSONObject(“sys”).getLong(“sunrise”) * 1000, json.getJSONObject(“sys”).getLong(“sunset”) * 1000);   }catch(Exception e){ Log.e(“SimpleWeather”, “One or more fields not found in the JSON data”); } }

At the closing stages of the renderWeather methodology, I will call into action the setWeatherIcon with the ID of the present weather in addition to the times of both the sunrise and sunset. Establishing the weather icon is a little bit complicated, since the OpenWeatherMap API supports a great array of the weather conditions than I can do with the web font that I am using. Providentially, the weather IDs take on a pattern, whose finer details are located at the OpenWeatherMap website.

Here is the manner in which I will map the weather IDs to the icons:

· The weather codes within the range of 200 will be encoded in relation to thunderstorms, which imply that I will use the R.string.weather_thunder for these

· The weather codes within the range of 300 will be encoded in relation to drizzling and I will use the R.string.weather_drizzle for these

· The weather codes within the range of 500 will be encoded in relation to rain and I will use the R.string.weather_rain for them

I will use the count of both the sunrise and sunset to display the moon or the sun, depending on the present time of the day and only when the weather is clear.

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

private void setWeatherIcon(int actualId, long sunrise, long sunset){ int id = actualId / 100; String icon = “”; if(actualId == 800){ long currentTime = new Date().getTime(); if(currentTime>=sunrise && currentTime<sunset) { icon = getActivity().getString(R.string.weather_sunny); } else { icon = getActivity().getString(R.string.weather_clear_night); } } else { switch(id) { case 2 : icon = getActivity().getString(R.string.weather_thunder); break; case 3 : icon = getActivity().getString(R.string.weather_drizzle); break; case 7 : icon = getActivity().getString(R.string.weather_foggy); break; case 8 : icon = getActivity().getString(R.string.weather_cloudy); break; case 6 : icon = getActivity().getString(R.string.weather_snowy); break; case 5 : icon = getActivity().getString(R.string.weather_rainy); break; } } weatherIcon.setText(icon); }

Since I want my app to handle and deal with more weather conditions, I will as well add extra case statements to the setWeatherIcon method’s switch statement.

Lastly I will add a changeCity methodology to the fragment so that the users are able to update the present city or region. I will only call the changeCity methodology into action from the main Activity class.

1 2 3

public void changeCity(String city){ updateWeatherData(city); }

12. Edit the Activity

During the project’s setup, Eclipse populated WeatherActivity.java with some boilerplate code. Replace the default implementation of the onCreate method with the one below in which we use the WeatherFragment. The onCreate method should look like this:

01 02 03 04 05 06 07 08 09 10 11

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_weather);   if (savedInstanceState == null) { getSupportFragmentManager().beginTransaction() .add(R.id.container, new WeatherFragment()) .commit(); } }

Subsequently, I will edit the onOptionsItemSelected method and deal with the lone option of the menu that I have. All I will have to do in this part is to bring into play the showInputDialog methododology.

Within the showInputDialog method, I will apply the AlertDialog.Builder to establish a Dialog item, which prompts the user to type the name of a city. This info will be passed on to the changeCity methodology, which keeps the city’s name with the help of the CityPreference class and calls the Fragment’s changeCity methodology.

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

@Override public boolean onOptionsItemSelected(MenuItem item) { if(item.getItemId() == R.id.change_city){ showInputDialog(); } return false; }   private void showInputDialog(){ AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle(“Change city”); final EditText input = new EditText(this); input.setInputType(InputType.TYPE_CLASS_TEXT); builder.setView(input); builder.setPositiveButton(“Go”, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { changeCity(input.getText().toString()); } }); builder.show(); }   public void changeCity(String city){ WeatherFragment wf = (WeatherFragment)getSupportFragmentManager() .findFragmentById(R.id.container); wf.changeCity(city); new CityPreference(this).setCity(city); }

At this point, my weather app will be ready. Whatever would come next will be installing it into an Android device for testing.

Observation

This was the main part of my project. The rationale is that it was the part, which entailed practical activities of assembling the tools with the help of the methodologies to yield the heart of this project, the software. Carrying out the development activities was averagely smooth courtesy to the foundation of the knowledge I laid down during the inception phase, where I prepared very well especially in terms of how to do the software development.

However, there are some sections, which I had barely covered no material on how to handle them. For a case in point, I had only checked on the tutorials on the basic steps and methods of developing an android application. I did not even narrow down to check on how to develop a weather application for the phones and tabs. For this reason, I occasionally got stack in at some points in the development process of my project. One crucial moment comes when I wanted to make my app better by making it able to read more weather conditions. While some times I had to put pending the entire project to go for some research on the point putting me and my entire project in dilemma, other times I applied my knowledge and skills to improvise and innovate my software. This aspect has been successful actually because as we speak, I just completed my app that is more advanced than what I anticipated to make at the beginning of the project.

Refection

It was a good task for my development in the software building field. It was a good experience. If there is one great thing that has for sure happened following the completion of this project is my transformation. I actually wind up the task a different person from that I was when I started it. Developing the software and on my own have improved my confidence and so my status. In the plan phase of this iteration, I was going through the tutorials and really wondered if I was getting anything and would manage the task on my own or I needed help. However, following this task, I think it was the last time I ever felt that. At the moment, I feel able; I feel that I am the one supposed to help the others and not me seeking help from them.

All the same, it was not easy. Perhaps that is why I feel like a hero to have done it. To me it feels like going to the moon and coming back. Downloading and installing the pug-in and the other tools on my computer was very bulky, tiresome and boring. Some tools just kept on downloading for hours while installing others heated up my computer and even made it unresponsive. Because shutting the PC down would mean the loss of some data and even files, I had to wait for as much as until the computer would become responsive again. Nonetheless, there are moments when the PC could not become responsive again after as much as much time as after 8 hours and so I shut it down. On coming back, I never picked up from where I was when I shut the PC down, but from some step back.

Iteration 4:

Stabilization (Testing) and Deployment (Installation)

In this iteration, I look at the stabilization and the deployment of my weather app. Stabilization will be dealing with the testing of the app will deployment will about the setup r rather the installation of the software.

Plan

Stabilization (Testing the Application)

In the contemporary society, applications are tested automatically rather using a computerized mechanism. Testing itself occurs at almost every stage of development of software. However, the building process can be completed first before the testing is executed. It is not a surprise on how automated testing of software has attracted an immense use. This kind of testing is itself proper and well fitting the current requirements of the need to save time and resources while maximizing quality and quantity. In particular, automated testing hugely reduces the time required time for a testing process, reduces errors and slips in tests execution emanating from the human factors.

A great array of the automated software testing tools exists on the market (Zadgaonkar, 2014). While the majority of these tools are free, others command some little price whilst a few are excessively expensive. Some of them are free, some are rather expensive. Some of these automation software testing tools were are obsolete having have been developed some years back, while some just came into the market in the recent past and presently. Basing on these statistics, every of the automated software testing tools come out as unique in its own way. As such, what is critical when it comes to the best testing results is the one’s choice of the automation software testing tool that it fits in the modern society and in the compatibilities of the software to be tested. Wide choice of available automation tools makes it difficult to select the most suitable ones for a project according to Wagner, (2011). The problem is that hardly any of the existing tools fully corresponds to project requirements.

In this phase, I will not be doing much. I will just put in the place the relevant factors to surf about these tools. As such, I will ensure that I have an in-form computer and a connection to the internet. This task should take me not more than two days.

Deployment (Installation of the App)

Installation is also called set up according to Baldwin & Bordoli, (2014). It refers to the process or the act of making a computer program, plugins, and device drivers ready for execution. Given that the predominance of these programs has different characteristics, hence greatly vary, in association with another fact that majority of the phones’ as it is for the case of the computers’ operating systems also vary, new software are often developed with their installers or set ups. A setup or an installer is a specialized program conscientious for installing a program or software on devices. Installation is usually a part of a larger application deployment process.

According to the United States, (2011) installation characteristically entails copying and or generating a code from the files of installation or from the installers to new files on the local phone device, tablet or computer for their easy access by the operating systems of the devices. Given that the codes are generally generated and or copied in multiple locations, Lewis, (2012) argues that ‘uninstallation’ of a software entails more than just deleting the folder of the program or application. For a case in point, the registry files, as well as the other system code, may necessitate an erase or modification for a complete uninstallation to occur (Purba & Shah, 2000).

A couple of applications can as well be deployed or rather installed by only copying them into a folder stored on a device like a phone or a computer and executing them. Since the predominance of the applications are supplied in a form, which cannot support immediate installation, supplying them with proper installation procedures in crucial. Following the first installation, these types of programs can be run on a device again and again without the necessity to reinstall prior to every execution. The following are some of the common operations, which occur during software installations:

· Checking if the necessary system specifications are met

· A read-through of the presented versions of the program

· Establishing and or updating the software files and folders

· Adding up the configuration data like Windows registry entries for the case of PCs, configuration files and or the environment variables

· Creating links, bookmarks, and shortcuts so that the program is accessible to the user

· Configuration of the elements, which run robotically, for instance, windows services and daemons,

· Activating the program and then,

· Updating the files of the program, hence itself

Depending on the software and is developer’s options, these operations may either be free or command some price. In the case of expenses, the costs of installation mean the expenses linked to and pertinent to or sustained as a result of deploying either the drivers or the product in the building of the user. It encompasses all the costs owed by the organization in respect of the verdict to get into this agreement with the user.

During the installation process, a few set ups try to trick the users into deploying junkware like a variety forms of trialware, adware, and toolbars or a program of a partnering organization. Following this case, Iversen & Eierman, (2014) urges the users to be very careful during the installation and especially on what exactly being asked to be deployed is needed so as to avoid this. As a result, any installation of the extra applications can simply be unchecked or passed over. However, this action may call for the user to use the “detailed,” the “custom”, or the “expert” version of the installation modus operandi. More so, such malevolent conduct may not necessarily be the decision or making of the program developers or their corporation but can as well emanate from the external installers like the Download.com, which is a set up by the CNET.

In this phase, I will seek to ensure that my software has a proper installation, although this occurred in the testing stage. While I already have enough information on installation and uninstallation and the risks that are associated, I will want to include a notification on the set up of my app. One thing I would want the user to know is that the program does not need any other extension or plug-in as it is already complete. Then I would also want to know that my app is not associated with ant adverts. I would then decide on the type of installation that I would incorporate in my program for easy use and management by the users.

Action

In this phase, my objective will be to make an effective and portable automated test for my software. However, this task will come after identifying the appropriate automation tool for my software. As such, here I will go on the internet and do the following;

· Clearly all the types of the automated software tools, which are available on the internet

· I will then formulate the specifications to the automated experiments and the tools for automation

· I will subsequently study at least quite a few accessible and more or less appropriate tools for automation;

· I will the narrow down and chose out the most proper one or more tools basing on my study on the appropriate tools

· It is at this point that I will then carry on doing the tests automation of my weather software.

· Such approach and sequence of steps would be approved by most of the quality assurance experts.

· Deployment

In this phase, I will do the configurations to incorporate my notifications in my installer. I will then configure the proper type of installation for my software. I will use the attended installation type. This type of installation is not only the most common one for the PCs alone but for other devices like phones and tablets as well.

Attended installation usually requires that a user pays attention to in and commands it on what to do, for instance, accepting some prompts, accepting some end user license agreement (EULA) or declining all of them. Many times, this type of installation also necessitates that the user specifies such preferences like the setup location, offering passwords and even some help in product activation. This is how I will configure my installer to behave like. In graphical surroundings, it is common to have the set ups, which offer a wizard-based interface. Since my setup will use the attended installation method, I will expect it to ask the users to help alleviate the errors. For a case in point, in case the disk in which the app is being installed gets full, the set up should ask the user to create some enough space on the disk or to identify a different target path to complete the installation.

Observation

On stabilization, while making a study and analysis of the available automation software testing tools, I settled on the Ranorex Android software testing contrivance. This tool shared a lot of compatibilities with my build software. On top of this factor, it was also up to date and free. The up to date factor implied that it was a product of the current technology, hence would be suitable for all the presently being developed apps. On the other hand, the being free factor signified the added advantage I had, of not incurring any further costs on my project.

Ranorex Mobile App Testing Tool

Ranorex Mobile App Testing Tool

Ranorex, according to Purba & Shah, (2000) is first-class automated software testing not only for the newest but as well for the early editions and sub-editions of phone and Android, commencing from the Android version 2.2. One of the clinical upper hands of Ranorex is its all-embracing reports, which comes along screenshots. Ranorex, as writes Wagner, (2011) can also connect a tablet or a phone to the internet through while in the testing process. Baldwin & Bordoli, (2014) argues that this tool also enables an automation test specialist to elaborate the data-driven tests, exclusive of the XML data format. In addition, courtesy of Purba & Shah, (2000), Ranorex Studio permits the automation test specialists to generate tests easily, as by just by a mouse click. Moreover, it enables the elaboration of the extra program components. These modules are crucial for use in the late development cycles for more intricate test states of affairs.

On deployment, on the other hand, there were a number of the installation methods. However, the attended installation method proved a better set up mechanism for my program. One reason is that it could enable the users to make decisions themselves, a factor which is crucial especially in this century.

Reflection

The Ranorex Mobile App Testing Tool was a proper tool for the testing of my app. However, it was not the best one as it also had its weaknesses. One thing about this too is that it was too general. What I mean by being general is that it could not tell whether my app would give accurate results or not. It only tested its system files and if it could install and run or not. More so, it as well could detect the errors, which were likely to occur later. It as well could give insights on whether any of the software files and or tools had been corrupted or not.

As such, I felt like I still had to do something in terms of testing so as to be sure with my app. I thought of installing it on my phone and try it in three days with temperature and rainfall and see if it could provide accurate forecasts. However, due to the time factor, I could not. Meanwhile, the installation type, the attended, was all the best that was there for my app.

References

Argonne National Lab., United States., United States., & Michalakes, J. (2011). Design of a next-generation regional weather research and forecast model. Washington, D.C: United States. Dept. of Energy.

Baldwin, A., & Bordoli, D. (2014). A handbook for construction planning and scheduling.

Birze, B. (2013). Software Practices (Waterfall): SDLC Design Phase.

Iversen, J., & Eierman, M. (2014). Learning mobile app development: A hands-on guide to building apps with iOS and Android.

Jolliffe, I. T., & Stephenson, D. B. (2012). Forecast verification: A practitioner’s guide in atmospheric science. Chichester, U.K: Wiley-Blackwell.

Kelley, M., & cornell univ ithaca ny school of electrical and computer engineering. (2003). Establishment of a Patrol Imager at AEOS for Space Weather and Mesospheric Studies. United States: cornell univ ithaca ny school of electrical and computer engineering.

Lewis, J. (2012). SDLC 100 Success Secrets – Software Development Life Cycle (SDLC) 100 Most asked Questions. Emereo Publishing.

Sunburst Communications (Firm), & Weather Channel (Television station : Atlanta, Ga.). (1997). Everything weather. Pleasantville, NY: Sunburst Communications.

Nudelman, G. (2013). Android design patterns: Interaction design solutions for developers. Indianapolis, In: Wiley.

O’Rourke, J. (2012). Flash mobile application development for dummies. Hoboken, N.J: John Wiley & Sons.

Parikh, S. R. (2008). An SDLC based data acquisition system.

Purba, S., & Shah, B. (2000). How to manage a successful software project: With Microsoft Project 2000. New York.

Shah, S., & Rahman, K. A. (2013). Android development tools for Eclipse. Birmingham, UK: Packt Pub.

United States. (2011). Weather forecasting: Important issues on automated weather processing system need resolution : briefing report to Congressional requesters. Washington, D.C: The Office.

United States., & United States. (2001). Better software planning needed at the Air Force’s Global Weather Central: Report to the Chairman, Committee on Government Operations, House of Representatives. Washington, D.C: U.S. General Accounting Office.

Vonder, H. T. H., Huang, A. H.-L., Society of Photo-optical Instrumentation Engineers., Colorado Photonics Industry Association., & Geological Society of America. (2004). Weather and environmental Satellites: 2-3 August, 2004, Denver, Colorado, USA. Bellingham, Wash: SPIE.

Wagner, R. (2011). Professional Flash mobile development: Creating Android and iPhone applications. Indianapolis, Ind: Wiley.

Zadgaonkar, H. (2014). Robotium automated testing for android. Place of publication not identified: Shroff Publishers & Distr.

Zhou, M. C., Li, H.-X., & Weijnen, M. P. C. (2015). Contemporary issues in systems science and engineering.