Tetris development for Android full report
computer science topics|
Active In SP
Joined: Jun 2010
22-06-2010, 09:27 PM
Tetris development for Android.doc (Size: 1.5 MB / Downloads: 268)
1.1 Purpose of the project and implimentation:
The purpose of the project and implimentation is to list down requirements for the Tetris application, which is submitted to JNTU University, Kakinada as part of the fulfillment of Bachelors of Technology course enrolled at Chaitanya Institute of Engineering and Technology.
Tetris is available in many forms and available on various devices like desktop computers, hand held devices like PDA etc. as of today.
1.3 Proposed system:
QTetris is an application for the Android phones, which are widely used in the foreign countries.
1.4 Feasibility study:
All project and implimentations are feasible if they have unlimited resources and infinite time. But the development of software is plagued by the scarcity of resources and difficult delivery rates. It is necessary and prudent to evaluate the feasibility of a project and implimentation at the earliest possible time. The three considerations are involved in the feasibility analysis.
1.4.1 Economic Feasibility:
This procedure is to determine the benefits and savings that are expected from a candidate system and compare with cost. If benefits outweigh cost then the decision is made to design and implement the system.
Otherwise further justification or alterations in proposed system that have to be made if it is having a change of being approved .This is an ongoing effort that improves in accuracy of each phase of the system lifecycle. For my project and implimentation I am not expecting any feasibility costs spent on this on this project and implimentation because here I am using open source environments.
1.4.2 Technical feasibility:
Technical feasibility centers on the existing mobile system (hardware, software etc...) and to what extent it can support the proposed addition if the budget is a serious constraint, then the project and implimentation is judged not feasible. The Technical feasibilities are important role in my project and implimentation because here I am using android operating system.
People are inherently resistant to change and mobiles have been known to facilitate change. In my project and implimentation a technical people require to configure the software and technical background is necessary to work on the sensors.
1.5 Intended Developers:
2. SCOPE OF PROJECT
The scope of this project and implimentation is to develop an Android based gaming application for Tetris. The game (or one of its many variants) is available for nearly every video game console and computer operating system, as well as on devices such as graphing calculators, mobile phones, portable media players, PDAs and even as an Easter egg on non-media products like oscilloscopes. It has even been played on the sides of various buildings, with the record holder for the world's largest fully functional game of Tetris being an effort by Dutch students in 1995 that lit up all 15 floors of the Electrical Engineering department at Delft University of Technology.
This project and implimentation is aimed to develop the Tetris game on Mobile phone.
3. PRODUCT PERSPECTIVE
This research is on the latest open source mobile development platform called, Android and to implement a game based technologies for different requirements.
3.1 Product Features:
Android is "openness." The promise is that developers can produce applications without interference.
"The fact that (Android) is an advanced, open operating system is important to the development community, but customers don't buy operating systems.
The interface is flexible.
The Android Platform provides a rich security model that allows developers to request the capabilities, or access, needed by their application and to define new capabilities that other applications can request.
Developers have full access to the same framework APIs used by the core applications
4. ASSUMPTIONS AND DEPENDENCIES
Having only hardware is not sufficient, to access an application Software is must.
Assumption is made in such a way that the mobile is charged with enough battery.
The battery should be in a working mode.
The one who using the mobile must have a minimum knowledge of how to play Tetris game.
5. SOFTWARE REQUIREMENT SPECIFICATION
5.1 Functional Requirements Specification
The system is required to perform the following functions.
1. Display all the information about the application that is being developed and some set of instructions the user might want to remember before he sets up the system for configuring global time.
2. Sign in your application with jar signer before running your application
3. Install your apk file with android bridge (i.e adb) .
4. After executing your application tetris
5. Ability to rotate the shapes in clockwise and anti clockwise direction.
6. Use up and down arrow keys for rotating.
7. Able to display score
8. Ability to pause and resume and stop the application
5.2 Non-Functional Requirements
Application framework enabling reuse and replacement of components.
Dalvik virtual machine optimized for mobile devices.
Integrated browser based on the open source Web Kit engine.
Optimized graphics powered by a custom 2D graphics library; 3D graphics based on the OpenGL ES 1.0 specification (hardware acceleration optional).
SQLite for structured data storage.
Rich development environment including a device emulator, tools for debugging, memory and performance profiling, and a plug-in for the Eclipse IDE.
The system is expected to run on low memory devices also.
The system should not consume lot of bandwidth so that the other applications will block for the internet.
The system should provide secured access to the web server.
5.3 Software Requirements:
J2SE, Android, Linux, Windows XP, Eclipse 3.4, Mobile IDE Plug-in.
5.4 Hardware Requirements:
Pentium IV with 2GHZ, 1 GB RAM, 40 GB Hard Drive, Android Phone (optional)
6. PROJECT ANALYSIS
Tetris is one of the few games that achieve ultimate popularity. It is remarkably simple, yet remarkably difficult. It's been ported to every computer and game console known to man, and has sold millions of cartridges, tapes, and disks across the land.
Besides that, it also led to one of the most interesting legal battles in the history of video games, leading to the famed Tengen version of Tetris and to the downfall of a few companies. It's a pretty cool story, so let's get down to business. Hold on for a second while I set the time machine to cruise control
Tetris has been involved in many legal battles. In June 1985, Alexey Pajitnov created Tetris on an Elektronika 60 while working for the Soviet Academy of Sciences at their Computer Center in Moscow with Dmitry Pavlovsky, and Vadim Gerasimov ported it to the IBM PC. Gerasimov reports that Pajitnov chose the name "Tetris" as "a combination of 'tetramino' and 'tennis'.
From there, the PC game exploded into popularity, and began spreading all around Moscow. This version is available on Gerasimov's web site.
Meanwhile, before any legal rights were settled, the Spectrum HoloByte IBM PC version of Tetris was released in the United States in 1986. The game's popularity was tremendous, and many players were instantly hookedâ€it was a software blockbuster, with reviews such as in Computer Gaming World calling the game "deceptively simple and insidiously addictive".
The details of the licensing issues were uncertain by this point, but in 1987 Andromeda managed to obtain copyright licensing for the IBM PC version and any other home computer system.
By 1988, the Soviet government began to market the rights to Tetris through an organization called Elektronorgtechnica, or "Elorg" for short. Pajitnov had granted his rights to the Soviet Government, via the Computer Center he worked at for ten years. By this time Elorg had still seen no money from Andromeda, and yet Andromeda was licensing and sub-licensing rights that they themselves did not even have.
By 1989, half a dozen different companies claimed rights to create and distribute the Tetris software for home computers, game consoles, and handheld systems. Elorg, meanwhile, held that none of the companies were legally entitled to produce an arcade version, and signed those rights over to Atari Games, while it signed non-Japanese console and handheld rights over to Nintendo.
Screenshot of the NES version of TETIS: the Soviet Mind Game
Pajitnov himself has made very little money from the deal, even though Nintendo profited greatly from the game.
In 1996, The Tetris Company LLC (TTC) was formed in an effort to derive revenue from TetrisTTC is now the exclusive licensee of Tetris Holding, LLC, which owns copyright registrations for Tetris products in the United States and trademark registrations for Tetris in most every country in the world. Tetris Holding through TTC has licensed its intellectual property to a number of companies. The U.S. Court of International Trade and the U.S. Customs have at times issued seizure orders to preclude knock-off Tetris games from being imported into the U.S., despite bulletins circulated by the U.S. Copyright Office stating that copyright does not apply to the rules of a game.
Due to the popularity of Tetris, there have also been many knock-off and lookalike games on the Internet, many with names confusingly similar to "Tetris". In order to stop this infringement, TTC and Tetris Holding have vigorously policed and enforced their rights and have sent cease-and-desist letters to websites that infringe the Tetris mark.
Effect of Tetris on the brain:
According to intensive research from Dr. Michael Crane and Dr. Richard Haier, et al. prolonged Tetris activity can also lead to more efficient brain activity during play. When first playing Tetris, brain function and activity increases, along with greater cerebral energy consumption, measured by glucose metabolic rate. As Tetris players become more proficient, their brains show a reduced consumption of glucose, indicating more efficient brain activity for this task. The game can also cause a repetitive stress symptom in that the brain will involuntarily picture Tetris combinations even when the player is not playing the game (the Tetris effect), although this can occur with any computer game showcasing repeated images or scenarios.
In January 2009, an Oxford University research group headed by Dr Emily Holmes reported in PLoS ONE that for healthy volunteers, playing ËœTetrisâ„¢ soon after viewing traumatic material in the laboratory reduced the number of flashbacks to those scenes in the following week. They believe that the computer game may disrupt the memories that are retained of the sights and sounds witnessed at the time, and which are later re-experienced through involuntary, distressing flashbacks of that moment. The group hope to develop this approach further as a potential intervention to reduce the flashbacks experienced in PTSD, but emphasized that these are only preliminary results.
7. PROJECT DESIGN
What is UML
The Unified Modeling Language (UML) is a standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems, as well as for business modeling and other non-software systems. The UML represents a collection of best engineering practices that have proven successful in the modeling of large and complex systems. The UML is a very important part of developing objects oriented software and the software development process. The UML uses mostly graphical notations to express the design of software project and implimentations. Using the UML helps project and implimentation teams communicate, explore potential designs, and validate the architectural design of the software.
Goals of UML:
The primary goals in the design of the UML were:
Provide users with a ready-to-use, expressive visual modeling language so they can develop and exchange meaningful models.
Provide extensibility and specialization mechanisms to extend the core concepts.
Be independent of particular programming languages and development processes.
Provide a formal basis for understanding the modeling language.
Encourage the growth of the OO tools market.
Support higher-level development concepts such as collaborations, frameworks, patterns and components. Integrate best practices.
Why Use UML
As the strategic value of software increases for many companies, the industry looks for techniques to automate the production of software and to improve quality and reduce cost and time-to-market. These techniques include component technology, visual programming, patterns and frameworks. Businesses also seek techniques to manage the complexity of systems as they increase in scope and scale. In particular, they recognize the need to solve recurring architectural problems, such as physical distribution, concurrency, replication, security, load balancing and fault tolerance. Additionally, the development for the World Wide Web, while making some things simpler, has exacerbated these architectural problems. The Unified Modeling Language (UML) was designed to respond to these needs.
UML diagram is designed to let developers and customers view a software system from a different perspective and in varying degrees of abstraction. UML diagrams commonly created in visual modeling tools include.
7.1 Use case Diagram:
A use case is a set of scenarios that describing an interaction between a user and a system. A use case diagram displays the relationship among actors and use cases. The two main components of a use case diagram are use cases and actors.
An actor is represents a user or another system that will interact with the system you are modeling. A use case is an external view of the system that represents some action the user might perform in order to complete a task.
When to Use: Use Cases Diagrams:
Use cases are used in almost every project and implimentation. They are helpful in exposing requirements and planning the project and implimentation. During the initial stage of a project and implimentation most use cases should be defined, but as the project and implimentation continues more might become visible.
7.2 Class Diagram:
Class diagrams are widely used to describe the types of objects in a system and their relationships. Class diagrams model class structure and contents using design elements such as classes, packages and objects. Class diagrams describe three different perspectives when designing a system, conceptual, specification, and implementation. These perspectives become evident as the diagram is created and help solidify the design. This example is only meant as an introduction to the UML and class diagrams. If you would like to learn more see the Resources page for more detailed resources on UML.
When to Use: Class Diagrams:
Class diagrams are used in nearly all Object Oriented software designs. Use them to describe the Classes of the system and their relationships to each other.
7.3 Sequence Diagram:
Sequence diagrams demonstrate the behavior of objects in a use case by describing the objects and the messages they pass. The diagrams are read left to right and descending. The example below shows an object of class 1 start the behavior by sending a message to an object of class 2. Messages pass between the different objects until the object of class 1 receives the final message.
Tetris Sequence diagram:
7.4 Activity Diagram:
Activity diagrams describe the workflow behavior of a system. Activity diagrams are similar to state diagrams because activities are the state of doing something. The diagrams describe the state of activities by showing the sequence of activities performed. Activity diagrams can show activities that are conditional or parallel.
When to Use: Activity Diagrams
Activity diagrams should be used in conjunction with other modeling techniques such as interaction diagrams and state diagrams. The main reason to use activity diagrams is to model the workflow behind the system being designed. Activity Diagrams are also useful for: analyzing a use case by describing what actions needs to take place and when they should occur; describing a complicated sequential algorithm; and modeling applications with parallel processes.
However, activity diagrams should not take the place of interaction diagrams and state diagrams. Activity diagrams do not give detail about how objects behave or how objects collaborate.
8. CODE IMPLEMENTATION
The Android platform is a software stack for mobile devices including an operating system, middleware and key applications. Developers can create applications for the platform using the Android SDK. Applications are written using the Java programming language and run on Dalvik, a custom virtual machine designed for embedded use, which runs on top of a Linux kernel. An embarrassing bug found on the G1 Phone has been fixed by Google. After starting up the phone if a user then typed reboot, the phone would reboot.
The bug was found accidentally by a user who happened to type Reboot into his phone.
Google moved quickly to fix the problem, users in the US are already reporting having received the update and according to the BBC, users in the UK will have the update by 12th November.
The G1 has had surprisingly few bugs for a phone that is based on a completely new platform and is the first phone to use it.
The following diagram shows the major components of the Android operating system. Each section is described in more detail below.
Android will ship with a set of core applications including an email client, SMS program, calendar, maps, browser, contacts, and others. All applications are written using the Java programming language.
Developers have full access to the same framework APIs used by the core applications. The application architecture is designed to simplify the reuse of components; any application can publish its capabilities and any other application may then make use of those capabilities (subject to security constraints enforced by the framework). This same mechanism allows components to be replaced by the user.
Underlying all applications is a set of services and systems, including:
A rich and extensible set of Views that can be used to build an application, including lists, grids, text boxes, buttons, and even an embeddable web browser
Content Providers that enable applications to access data from other applications (such as Contacts), or to share their own data
A Resource Manager, providing access to non-code resources such as localized strings, graphics, and layout files
A Notification Manager that enables all applications to display custom alerts in the status bar
An Activity Manager that manages the life cycle of applications and provides a common navigation back stack
Android includes a set of C/C++ libraries used by various components of the Android system. These capabilities are exposed to developers through the Android application framework. Some of the core libraries are listed below:
System C library - a BSD-derived implementation of the standard C system library (libc), tuned for embedded Linux-based devices
Media Libraries - based on Packet Videoâ„¢s Open CORE; the libraries support playback and recording of many popular audio and video formats, as well as static image files, including MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG
Surface Manager - manages access to the display subsystem and seamlessly composites 2D and 3D graphic layers from multiple applications
LibWebCore - a modern web browser engine which powers both the Android browser and an embeddable web view
SGL - the underlying 2D graphics engine
3D libraries - an implementation based on OpenGL ES 1.0 APIs; the libraries use either hardware 3D acceleration (where available) or the included, highly optimized 3D software rasterizer
FreeType - bitmap and vector font rendering
SQLite - a powerful and lightweight relational database engine available to all applications
Android includes a set of core libraries that provides most of the functionality available in the core libraries of the Java programming language.
Every Android application runs in its own process, with its own instance of the Dalvik virtual machine. Dalvik has been written so that a device can run multiple VMs efficiently. The Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The VM is register-based, and runs classes compiled by a Java language compiler that have been transformed into the .dex format by the included "dx" tool.
The Dalvik VM relies on the Linux kernel for underlying functionality such as threading and low-level memory management.
Android relies on Linux version 2.6 for core system services such as security, memory management, process management, network stack, and driver model. The kernel also acts as an abstraction layer between the hardware and the rest of the software stack.
8.2 Eclipse 3.4:
An open-source Java IDE and platform for rich client applications Eclipse is an open source platform-independent software framework for delivering what the project and implimentation calls or is known as "rich-client applications" (as opposed to "thin clients", this means the clients perform heavy-duty work on the host.
So far this framework has typically been used to develop Ides (Integrated Development Environments), such as the highly-regarded Java IDE called Java Development Toolkit (JDT) and compiler that come as part of Eclipse (and which are also used to develop Eclipse itself). However, it can be used for other types of client application as well, see the popular Bit Torrent client for example.
OVERVIEW OF JAVA:
Computers connected to the net are from many different manufacturers, running on different operating systems and they differ in architecture, computing power and capacity. By considering this point SUN Microsystems Corporation felt the need for a new programming language suitable for this heterogeneous Environment and java was the solution. This breaks barriers between different computers, chips and operating Systems. .
The main properties of the Java, which made Java so popular, are as follows:
The Key Features Of Java Is Byte Code:
The key that allows Java to solve both the security and the portability problems just described is that the output of a Java compiler is not executable code. Rather, it is Byte code. Byte code is a highly optimized set of instructions designed to be executed by the Java runtime systems, which is called the Java Virtual Machine (JVM). That is, in its standard form, the JVM is an interpreter for Byte code. This may come has a bit of surprise.
One characteristic of Java is portability, which means that computer programs written in the Java language must run similarly on any supported hardware/operating-system platform. One should be able to write a program once, compile it once, and run it anywhere.
This is achieved by compiling the Java language code, not to machine code but to Java bytecode â€œ instructions analogous to machine code but intended to be interpreted by a virtual machine (VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE) installed on their own machine for standalone Java applications, or in a Web browser for Java applets.
Standardized libraries provide a generic way to access host specific features such as graphics, threading and networking. In some JVM versions, bytecode can be compiled to native code, either before or during program execution, resulting in faster execution.
A major benefit of using bytecode is porting. However, the overhead of interpretation means that interpreted programs almost always run more slowly than programs compiled to native executables would, and Java suffered a reputation for poor performance. This gap has been narrowed by a number of optimisation techniques introduced in the more recent JVM implementations.
One such technique, known as just-in-time (JIT) compilation, translates Java bytecode into native code the first time that code is executed, then caches it. This result in a program that starts and executes faster than pure interpreted code can, at the cost of introducing occasional compilation overhead during execution. More sophisticated VMs also use dynamic recompilation, in which the VM analyzes the behavior of the running program and selectively recompiles and optimizes parts of the program.
Dynamic recompilation can achieve optimizations superior to static compilation because the dynamic compiler can base optimizations on knowledge about the runtime environment and the set of loaded classes, and can identify hot spots - parts of the program, often inner loops, that take up the most execution time. JIT compilation and dynamic recompilation allow Java programs to approach the speed of native code without losing portability.
8.4 Android SDK:
The Android SDK includes a comprehensive set of development tools. These include a debugger, libraries, a handset emulator (based on QEMU), documentation, sample code, and tutorials. Currently supported development platforms include x86-based computers running Linux (any modern desktop Linux Distribution), Mac OS X 10.4.8 or later, Windows XP or Vista. Requirements also include Java Development Kit, Apache Ant, and Python 2.2 or later. The officially supported integrated development environment (IDE) is Eclipse (3.2 or later) using the Android Development Tools (ADT) Plug-in, though developers may use any text editor to edit Java and XML files then use command line tools to create, build and debug Android applications.
A preview release of the Android software development kit (SDK) was released on 12 November 2007. On 15 July 2008, the Android Developer Challenge Team accidentally sent an email to all entrants in the Android Developer Challenge announcing that a new release of the SDK was available in a "private" download area. The email was intended for winners of the first round of the Android Developer Challenge. The revelation that Google was supplying new SDK releases to some developers and not others (and keeping this arrangement private) have led to widely reported frustration within the Android developer community.
On 18 August 2008 the Android 0.9 SDK beta was released. This release provides an updated and extended API, improved development tools and an updated design for the home screen. Detailed instructions for upgrading are available to those already working with an earlier release. On 23 September 2008 the Android 1.0 SDK (Release 1) was released. According to the release notes, it included "mainly bug fixes, although some smaller features were added". It also included several API changes from the 0.9 version.
On March 9, 2009, Google released version 1.1 for the android dev phone. While there are a few aesthetic updates, a few crucial updates include support for "search by voice, priced apps, alarm clock fixes, sending gmail freeze fix, fixes mail notifications and refreshing intervals, and now the maps show business reviews". Another important update is that Dev phones can now access paid apps and developers can now see them on the Google marketplace.
What is testing
A process of executing a program with the explicit intention of finding errors, that is making the program fail. Testing is the process of detecting errors. Testing performs a very critical role for quality assurance and for ensuring the reliability of software. The results of testing are used later on during maintenance also.
Psychology of Testing
The aim of testing is often to demonstrate that a program works by showing that it has no errors. The basic purpose of testing phase is to detect the errors that may be present in the program. Hence one should not start testing it the intent of showing that a program works but the intent should be to show that a program does not work. Testing is the process of executing a program with the intent of finding errors.
The main objective of testing is to uncover a host of errors, systematically and with minimum effort and time. Stating formally, we can say,
Testing is a process of executing a program with the intent of finding an error.
A successful test is one that uncovers an as yet discovered error.
A good test case is one that has a high probability of finding error, if it exists.
The tests are inadequate to detect possibly present errors.
The software more or les confirms to the quality and reliable standards.
It is the process of testing the functionality and correctness of a software by running it. A good test case is the one that has a high probability of finding an as yet undiscovered error. A successful test is one that uncovers an as yet undiscovered error. Software testing is usually performed for one of the two reasons.
Black Box Testing:
Black box testing is based on the softwareâ„¢s specifications or requirements, without reference to its internal workings
Black Box Testing is not a type of testing; it instead is a testing strategy, which does not need any knowledge of internal design or code etc. As the name "black box" suggests, no knowledge of internal logic or code structure is required. The types of testing under this strategy are totally based/focused on the testing for requirements and functionality of the work product/software application. Black box testing is sometimes also called as "Opaque Testing", "Functional/Behavioral Testing" and "Closed Box Testing".
The base of the Black box testing strategy lies in the selection of appropriate data as per functionality and testing it against the functional specifications in order to check for normal and abnormal behavior of the system. Now a days, it is becoming common to route the Testing work to a third party as the developer of the system knows too much of the internal logic and coding of the system, which makes it unfit to test the application by the developer.
In order to implement Black Box Testing Strategy, the tester is needed to be thorough with the requirement specifications of the system and as a user, should know, how the system should behave in response to the particular action.
White Box Testing:
White box testing is a security testing method that can be used to validate whether code implementation follows intended design, to validate implemented security functionality, and to uncover exploitable vulnerabilities White box testing is performed based on the knowledge of how the system is implemented. White box testing includes analyzing data flow, control flow, information flow, coding practices, and exception and error handling within the system, to test the intended and unintended software behavior. White box testing can be performed to validate whether code implementation follows intended design, to validate implemented security functionality, and to uncover exploitable vulnerabilities.
White box testing requires access to the source code. Though white box testing can be performed any time in the life cycle after the code is developed, it is a good practice to perform white box testing during the unit testing phase.
White box testing requires knowing what makes software secure or insecure, how to think like an attacker, and how to use different testing tools and techniques. The first step in white box testing is to comprehend and analyze source code, so knowing what makes software secure is a fundamental requirement. Second, to create tests that exploit software, a tester must think like an attacker. Third, to perform testing effectively, testers need to know the different tools and techniques available for white box testing. The three requirements do not work in isolation, but together.
Knowing the internal working i.e., to test if all internal operations are performed according to program structures and data structures. To test if all internals components have been adequately exercised.
Levels of Testing:
In order to uncover the errors present in different phases we have the concept of levels of testing. The basic levels of testing are
Client needs Acceptance Testing
Requirements System Testing
Design Integration Testing
Code Unit Testing
Software Testing Strategies:
A strategy for software testing will begin in the following order.
It concentrates on each unit of the software as implemented in source code and is a white box oriented. Using the component level design description as a guide, important control paths are tested to uncover errors with in the boundary of the module. In the unit testing, the steps can be conducted in parallel for multiple components. In my project and implimentation I tested all the modules individually related to main function codes and attacks also.
Here focus is on design and construction of the software architecture. Integration Testing is a systematic technique for constructing the program structure while at the same time conducting tests to uncover errors associated with interfacing. The objective is to take unit tested components and build a program structure that has been dictated by design. The goal here is to see if modules can be integrated properly, the emphasis being on testing interfaces between modules.
This testing activity can be considered as testing the design and hence the emphasis on testing module interactions. In this project and implimentation the main system is formed by integrating all the modules. When integrating all the modules I have checked whether the integration effects working of any of the services by giving different combinations of inputs with which the two services run perfectly before integration.
In this, requirements established as part of software requirement analysis are validated against the software that has been constructed i.e., validation succeeds when software functions in a manner that can reasonably expected by the customer.
System testing of software or hardware is testing conducted on a complete, integrated system to evaluate the system's compliance with its specified requirements. System testing falls within the scope of black box testing, and as such, should require no knowledge of the inner design of the code or logic.
Here the entire software system is tested. The reference document for this process is the requirements document, and the goal is to see if software meets its requirements.
9.1 TEST CASES:
A test case in software engineering is a set of conditions or variables under which a tester will determine whether an application or software system meets specifications. The mechanism for determining whether a software program or system has passed or failed such a test is known as a test oracle. In some settings an oracle could be a requirement or use case. It may take many test cases to determine that a software program or system is functioning correctly. Test cases are often referred to as test scripts, particularly when written. Written test cases are usually collected into test suites.
What are positive and negative test cases
A positive test case is when the test is designed to return what is
expected according to the requirement.
Negative test case is when the test is designed to determine the
response of the product outside of what is defined.
10. OUTPUT SCREENS
11. FUTURE SCOPE
Currently the application only supports the Tetrominoes to drop from top to bottom, the application can also be extended to move Tetrominoes from bottom to top, the project and implimentation can also be extended to have different levels, based on the level we can make Tetrominoes to drop at increasing speeds.
Finally we concluded that the QTetris is a game application developed on a new mobile platform Android, and for the users who loves playing games, it also helps users to get relaxed from heavy work.
The following terms are used in these documents.
The extension for an Android package file, which typically contains all of the files related to a single Android application. The file itself is a compressed collection of an AndroidManifest.xml file, application code (.dex files), resource files, and other files. A project and implimentation is compiled into a single .apk file.
Android programs are compiled into .dex (Dalvik Executable) files, which are in turn zipped into a single .apk file on the device. .dex files can be created by automatically translating compiled applications written in the Java programming language.
A description of something that an Intent sender wants done. An action is a string value assigned to Intent. Action strings can be defined by Android or by a third-party developer. For example, android.intent.action.VIEW for a Web URL, or com.example.rumbler.SHAKE_PHONE for a custom application to vibrate the phone.
A single screen in an application, with supporting Java code, derived from the Activity class.
Android Debug Bridge, a command-line debugging application shipped with the SDK. It provides tools to browse the device, copy tools on the device, and forward ports for debugging. See Using adb for more information.
A collection of one or more activities, services, listeners, and intent receivers. An application has a single manifest, and is compiled into a single .apk file on the device.
A class built on ContentProvider that handles content query strings of a specific format to return data in a specific format. See Reading and writing data to a content provider for information on using content providers.
A type of URI. See the URI entry.
The name of Android's virtual machine. The Dalvik VM is an interpreter-only virtual machine that executes files in the Dalvik Executable (.dex) format, a format that is optimized for efficient storage and memory-mappable execution. The virtual machine is register-based, and it can run classes compiled by a Java language compiler that have been transformed into its native format using the included "dx" tool. The VM runs on top of Posix-compliant operating systems, which it relies on for underlying functionality (such as threading and low level memory management). The Dalvik core class library is intended to provide a familiar development base for those used to programming with Java Standard Edition, but it is geared specifically to the needs of a small mobile device.
Dalvik Debug Monitor Service, a GUI debugging application shipped with the SDK. It provides screen capture, log dump, and process examination capabilities. See Using the Dalvik Debug Monitor Server to learn more about this program.
A compiled visual resource that can be used as a background, title, or other part of the screen. It is compiled into an android.graphics.drawable subclass.
A class (Intent) that contains several fields describing what a caller would like to do. The caller sends this intent to Android's intent resolver, which looks through the intent filters of all applications to find the activity most suited to handle this intent. Intent fields include the desired action, a category, a data string, the MIME type of the data, a handling class, and other restrictions.
Activities and intent receivers include one or more filters in their manifest to describe what kinds of intents or messages they can handle or want to receive. An intent filter lists a set of requirements, such as data type, action requested, and URI format, that the Intent or message must fulfill. For activities, Android searches for the activity with the most closely matching valid match between the Intent and the activity filter. For messages, Android will forward a message to all receivers with matching intent filters.
An application class that listens for messages broadcast by calling Context.sendBroadcast (). For example code, see Listening for and broadcasting global messages.
An XML file that describes the layout of an Activity screen.
An XML file associated with each Application that describes the various activies, intent filters, services, and other items that it exposes. See AndroidManifest.xml File Details.
Android uses URI strings both for requesting data (e.g., a list of contacts) and for requesting actions (e.g., opening a Web page in a browser). Both are valid URI strings, but have different values. All requests for data must start with the string "content://". Action strings are valid URIs that can be handled appropriately by applications on the device; for example, a URI starting with "" will be handled by the browser.
Use Search at http://topicideas.net/search.php wisely To Get Information About Project Topic and Seminar ideas with report/source code along pdf and ppt presenaion
Joined: Jul 2011
02-02-2012, 09:55 AM
to get information about the topic android full report ,ppt and related topic refer the link bellow
topicideashow-to-android-project and implimentation-ideas-for-students