Techno Talk

Handling animation life lycle events android

Now that you are happy with your animations, you just need to make
QuizSplashActivity transition to QuizMenuActivity when the animations
are complete. To do this, you create a new Intent control to launch the
QuizMenuActivity class and call the startActivity() method. You should also
call the finish() method of QuizSplashActivity because you do not want to keep
this activity on the stack (that is, you do not want the Back button to return to this
screen).

Of your animations, the fade_in2 animation takes the longest, at 5 seconds total.
This animation is therefore the one you want to trigger your transition upon. You do so by creating an AnimationListener object, which has callbacks for the animation life cycle events: start, end, and repeat. In this case, only the onAnimationEnd() method has an interesting implementation. Here is the code to create the AnimationListener and implement the onAnimationEnd() callback:

Animation fade2 = AnimationUtils.loadAnimation(this, R.anim.fade_in2);
fade2.setAnimationListener(new AnimationListener() {
public void onAnimationEnd(Animation animation) {
startActivity(new Intent(QuizSplashActivity.this,
QuizMenuActivity.class));
QuizSplashActivity.this.finish();
}
});

Now if you run the Been There, Done That! application again, either on the emulator or on the handset, you see some nice animation on the splash screen. The user then transitions smoothly to the main menu screen, which is the next screen on your to-do list.

How to animate all views in a Layout android

In addition to applying animations to individual View controls, you can also apply
them to each child View control within a Layout (such as TableLayout and each
TableRow), using LayoutAnimationController.
To animate View controls in this fashion, you must load the animation, create
LayoutAnimationController, configure it as necessary, and then call the layout’s
setLayoutAnimation() method. For example, the following code loads the custom_anim animation, creates a LayoutAnimationController, and then applies it to each TableRow in the TableLayout control:

Animation spinin = AnimationUtils.loadAnimation(this, R.anim.custom_anim);
LayoutAnimationController controller =new LayoutAnimationController(spinin);
TableLayout table = (TableLayout) findViewById(R.id.TableLayout01);
for (int i = 0; i < table.getChildCount(); i++)

{
TableRow row = (TableRow) table.getChildAt(i);
row.setLayoutAnimation(controller);
}
There is no need to call any startAnimation() method in this case because
LayoutAnimationController handles that for you. Using this method, the animation is applied to each child view, but each starts at a different time. (The default is 50% of the duration of the animation—which, in this case, would be 1 second.) This gives you the nice effect of each ImageView spinning into existence in a cascading fashion.
Stopping LayoutAnimationController animations is no different from stopping
individual animations: You simply use the clearAnimation() method. The additional lines to do this in the existing onPause() method are shown here:

TableLayout table = (TableLayout) findViewById(R.id.TableLayout01);
for (int i = 0; i < table.getChildCount(); i++) {
TableRow row = (TableRow) table.getChildAt(i);
row.clearAnimation();
}

How to animate Specific Views in android

Animations must be applied and managed programmatically. Remember, costly
operations, such as animations, should be stopped if the application is paused for
some reason. The animation can resume when the application comes back into theforeground.
Let’s start with a simplest case: applying the fade_in animation to your title
TextView control, called TextViewTopTitle. All you need to do is retrieve an
instance of your TextView control in the onCreate() method of the
QuizSplashActivity class, load the animation resource into an Animation object,
and call the startAnimation() method of the TextView control:
TextView logo1 = (TextView) findViewById(R.id.TextViewTopTitle);
Animation fade1 = AnimationUtils.loadAnimation(this, R.anim.fade_in);
logo1.startAnimation(fade1);

When an animation must be stopped—for instance, in the onPause() method of the activity—you simply call the clearAnimation() method. For instance, the following
onPause() method demonstrates this for the corner logos:
@Override
protected void onPause() {
super.onPause();
// Stop the animation
TextView logo1 = (TextView) findViewById(R.id.TextViewTopTitle);
logo1.clearAnimation();
TextView logo2 = (TextView) findViewById(R.id.TextViewBottomTitle);
logo2.clearAnimation();
// ... stop other animations
}

How to add animation resources in android

For your splash screen, you need to create three custom animations in XML and
save them to the /res/anim resource directory: fade_in.xml, fade_in2.xml, and
custom_anim.xml.
The first animation, fade_in.xml, simply fades its target from an alpha value of 0
(transparent) to an alpha value of 1 (opaque) over the course of 2500 milliseconds, or 2.5 seconds. There is no built-in animation editor in Eclipse. The XML for the fade_in.xml animation looks like this:

<?xml version=”1.0” encoding=”utf-8” ?>
<set
xmlns:android=”http://schemas.android.com/apk/res/android”
android:shareInterpolator=”false”>
<alpha
android:fromAlpha=”0.0”
android:toAlpha=”1.0”
android:duration=”2500”>
</alpha>
</set>

You can apply this animation to the top TextView control with your title text.
Next, you create the fade_in2.xml animation. This animation does exactly the
same thing as the fade_in animation, except that you set the startOffset attribute
to 2500 milliseconds. This means that this animation will actually take 5 seconds
total: It waits 2.5 seconds and then fades in for 2.5 seconds. Because 5 seconds
is long enough to display the splash screen, you should plan to listen for fade_in2
to complete and then transition to the main menu screen.
Finally, you need some fun animation sequence for the TableLayout graphics. In
this case, your animation set contains multiple, simultaneous operations: a rotation, some scaling, and an alpha transition. As a result, the target View spins into existence.

The custom_anim.xml file looks like this:

<?xml version=”1.0” encoding=”utf-8” ?>
<set
xmlns:android=”http://schemas.android.com/apk/res/android”
android:shareInterpolator=”false”>
<rotate
android:fromDegrees=”0”
android:toDegrees=”360”
android:pivotX=”50%”
android:pivotY=”50%”
android:duration=”2000” />
<alpha
android:fromAlpha=”0.0”
android:toAlpha=”1.0”
android:duration=”2000”>
</alpha>
<scale
android:pivotX=”50%”
android:pivotY=”50%”
android:fromXScale=”.1”
android:fromYScale=”.1”
android:toXScale=”1.0”
android:toYScale=”1.0”
android:duration=”2000” />
</set>

As you can see, the rotation operation takes 2 seconds to rotate from 0 to
360 degrees, pivoting around the center of the view. The alpha operation should
look familiar; it simply fades in over the same 2-second period. Finally, the scale
operation scales from 10% to 100% over the same 2-second period. This entire animation takes 2 seconds to complete.
After you have saved all three of your animation files, you can begin to apply the
animations to specific views.

How to work with animation in android

One great way to add zing to your splash screen would be to add some animation.The Android platform supports four types of graphics animation:

Animated GIF images—Animated GIFs are self-contained graphics files with
multiple frames.

Frame-by-frame animation—The Android SDK provides a similar mechanism
for frame-by-frame animation in which the developer supplies the individual graphic frames and transitions between them (see the AnimationDrawable class).

Tweened animation—Tweened animation is a simple and flexible method of
defining specific animation operations that can then be applied to any view
or layout.

OpenGL ES—Android’s OpenGL ES API provides advanced three-dimensional
drawing, animation, lighting, and texturing capabilities.

For your application, the tweened animation makes the most sense. Android provides tweening support for alpha (transparency), rotation, scaling, and translating (moving) animations. You can create sets of animation operations do be done simultaneously, in a timed sequence, and after a delay. Thus, tweened animation is a perfect choice for your splash screen.With tweened animation, you create an animation sequence, either programmatically or by creating animation resources in the /res/anim directory. Each animation sequence needs its own XML file, but the animation may be applied to any number of View controls.

Microsoft gives manufacturers a taste of Mango

Microsoft announced this morning that the next version of the Windows Phone operating system, code-named Mango, has been delivered to manufacturers, which can begin testing it on their handsets.

The move is one of the final steps before the software arrives on new phones and is delivered to existing users as a software update.

"This marks the point in the development process where we hand code to our handset and mobile-operator partners to optimize Mango for their specific phone and network configurations," Terry Myerson, Microsoft's corporate vice president of engineering for Windows phone. "Here on the Windows Phone team, we now turn to preparing for the update process."

Multitasking in Mango, coming to Windows Phone 7 users in the fall.

skype for android hacked and cracked to allow 3g calling

That Skype app for Android we thought was locked down to Wi-Fi only has just been cracked a few days after its release. The .apk is provided by xeudoxus over at Droid Forums, he tweaked it to get that pesky 3G block off, and apparently its working like a charm. So now all we need is an .apk that works on the Samsung Galaxy S.

Angry Birds v1.6.2 a game iPhone iPod Touch iPad

If you don’t know what Angry Birds game is, then you have been living in a cave! Angry Birds is simply the most spectacular, funny, intriguing game that will steal hundreds of hours from your spare time! It was first released for Apple iOS (iPad, iPod and iPhone) in December 2009 and became so famous that a computer version was released (it was released for almost all platforms indeed). With more than 100 million downloads across all platforms, Angry Birds is one of the most downloaded game on the Internet.

this is the beautiful snap of angry birds game

Gmail Notifier Pro v2.7.2 Multilingual Read Nfo-PH

PH group have released updated version of Gmail Notifier Pro, desktop notifier for your gmail account(s), available as regular and portable edition.

Gmail Notifier Pro is a lightweight and easy to use program that allows you to verify multiple Google Gmail accounts for new mail and notify the user. It has a simple and comprehensive interface that will quickly guide you through all its features.

Some of it's features are as under:

Check multiple Gmail accounts for new mail – including Google Apps accounts
Display popup notifications and play sound to alert the user when a new mail arrives
Define themes and configure accounts individually
Complete overview of all unread mail in all your mail boxes
Support Atom and IMAP protocols

How to design Layouts Using the Layout Resource Editor

You can design and preview layouts in Eclipse by using the layout resource editor
as shown in the below figure. If you click on the project file /res/layout/main.xml, you see a Layout tab, which shows you the preview of the layout. You can add and remove layout controls by using the Outline tab. You can set individual properties and attributes by using the Properties tab.

Like most other user interface designers, the layout resource editor works well for

basic layout design. However, the layout resource editor does not fully support all
View controls. For some of the more complex user interface controls, you might be
forced to edit the XML by hand. You might also lose the ability to preview your layout if you add any of these controls to your layout. In such a case, you can still view your layout by running your application in the emulator or on a handset.
Displaying an application correctly on a handset, rather than the Eclipse layout editor, should be a developer’s primary objective.

Information of android menifest file

The Android manifest file, named AndroidManifest.xml, is an XML file that must be included at the top level of any Android project. The Android system uses the information in this file to do the following:

Install and upgrade the application package
Display application details to users
Launch application activities
Manage application permissions
Handle a number of other advanced application configurations, including acting
as a service provider or content provider.

You can edit the Android manifest file by using the Eclipse manifest file resource
editor or by manually editing the XML.
The Eclipse manifest file resource editor organizes the manifest information into
categories presented on five tabs:

Manifest
Application
Permissions
Instrumentation
AndroidManifest.xml

Working with layouts in android

Most Android application user interfaces are defined using specially formatted XML
files called layouts. Layout resource files are included in the /res/layout directory.
You compile layout files into your application as you would any other resources.

Here is an example of a layout resource file:

<?xml version=”1.0” encoding=”utf-8”?>
<LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”>
<TextView
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”@string/hello” />
</LinearLayout>
You might recognize this layout: It is the default layout, called main.xml, created
with any new Android application. This layout file describes the user interface of the only activity within the application. It contains a LinearLayout control that is used as a container for all other user interface controls—in this case, a single TextView control. The main.xml layout file also references another resource: the string resource called @string/hello, which is defined in the strings.xml resource file.
There are two ways to format layout resources. The simplest way is to use the layout resource editor in Eclipse to design and preview layout files. You can also edit the XML layout files directly.

READ MORE » Working with layouts in android

How to access image resources programatically android

Images resources are encapsulated in the class BitmapDrawable. To access a graphic resource file called /res/drawable/logo.png, you would use the getDrawable() method, as follows:

BitmapDrawable logoBitmap =
(BitmapDrawable)getResources().getDrawable(R.drawable.logo);

Most of the time, however, you don’t need to load a graphic directly. Instead, you
can use the resource identifier as an attribute on a control such as an ImageView
control. The following code, for example, sets and loads the logo.png graphic into
an ImageView control named LogoImageView, which must be defined within the
layout:

ImageView logoView = (ImageView)findViewById(R.id.LogoImageView);
logoView.setImageResource(R.drawable.logo);

Image formats supported in anroid

Supported images format their description and required extension is given below

Supported Image Format          Description                   Required Extension

Portable Network Graphics          Preferred format                    .png

Nine-Patch Stretchable Images       Preferred format                   .9.png

Joint Photographic Experts Group    Acceptable format .jpg

Graphics Interchange Format               Discouraged but .gif

How to work with Dimensions in android

To specify the size of a user interface control such as a Button or TextView control,you need to specify different kinds of dimensions. You tag dimension resources with the <dimen> tag and store them in the resource file /res/values/dimens.xml. This XML resource file is not created by default and must be created manually.

Here is an example of a dimension resource file:
<?xml version=”1.0” encoding=”utf-8”?>
<resources>
<dimen name=”thumbDim”>100px</dimen>
</resources>
Each dimension resource value must end with a unit of measurement. Given below is the list that shows the dimension units that Android supports.

Type of Measurement        Description                           Unit String
Pixels                               Actual screen pixels                     px
Inches                              Physical measurement                 in
Millimeters                          Physical measurement                 mm
Points                                Common font measurement          pt
Density-independent pixels Pixels relative to 160dpi                dp
Scale-independent pixels     Best for scalable font display         sp

Working with color in android

You can apply color resources to screen controls. You tag color resources with the
<color> tag and store them in the file /res/values/colors.xml. This XML
resource file is not created by default and must be created manually.

Here is an example of a color resource file:
<?xml version=”1.0” encoding=”utf-8”?>
<resources>
<color name=”background_color”>#006400</color>
<color name=”app_text_color”>#FFE4C4</color>
</resources>
The Android system supports 12-bit and 24-bit colors in RGB format. Given below is the list that how many color formats that the Android platform supports.

Color Formats Supported in Android

Format                  Description                         Example
#RGB                     12-bit color                       #00F (blue)
#ARGB                 12-bit color with alpha         #800F (blue, alpha 50%)
#RRGGBB             24-bit color                        #FF00FF (magenta)
#AARRGGBB        24-bit color with alpha         # 80FF00FF (magenta, alpha 50%)

The following code retrieves a color resource named app_text_color using the
getColor() method:
int textColor = getResources().getColor(R.color.app_text_color);

READ MORE » Working with color in android

How to log android application information

Android provides a useful logging utility class called android.util.Log. Logging
messages are categorized by severity (and verbosity), with errors being the most
severe. Below see some commonly used logging methods of the Log class.

Method               Purpose

Log.e() Logs errors
Log.w()                Logs warnings
Log.i()                  Logs informational messages
Log.d()                 Logs debug messages
Log.v()                 Logs verbose messages

The first parameter of each Log method is a string called a tag. One common
Android programming practice is to define a global static string to represent the
overall application or the specific activity within the application such that log filters
can be created to limit the log output to specific data.
For example, you could define a string called TAG, as follows:
private static final String TAG = “MyApp”;
Now anytime you use a Log method, you supply this tag. An informational logging
message might look like this:
Log.i(TAG, “In onCreate() callback method”);

How to use dialogue methods of activity class

Methods and their purpose

(1)Activity.showDialog()

Shows a dialog, creating it if necessary.

(2)Activity.onCreateDialog()

Is a callback when a dialog is being created for the first time and added to the activity dialog pool.

(3)Activity.onPrepareDialog()

Is a callback for updating a dialog on-the-fly.Dialogs are created once and can be used many times by an activity. This callback enables the dialog to be updated just before it is shown for each showDialog() call.

(4)Activity.dismissDialog()

Dismisses a dialog and returns to the activity. The dialog is still available to be used again by calling showDialog() again.

(5)Activity.removeDialog()

Removes the dialog completely from the activity dialog pool.

Activity classes can include more than one dialog, and each dialog can be created
and then used multiple times.

You can also create an entirely custom dialog by designing an XML layout file and
using the Dialog.setContentView() method. To retrieve controls from the dialog
layout, you simply use the Dialog.findViewById() method.

How to provide input to android emulator

As a developer, you can adopt any one of the below way to provide input to the emulator:

. Use your computer mouse to click, scroll, and drag items (for example, side
volume controls) onscreen as well as on the emulator skin.
. Use your computer keyboard to input text into controls.
. Use your mouse to simulate individual finger presses on the soft keyboard or
physical emulator keyboard.
. Use a number of emulator keyboard commands to control specific emulator
states.

How to use Intents to launch other applications

Initially, an application may only be launching activity classes defined within its own package. However, with the appropriate permissions, applications may also launch external activity classes in other applications.
There are well-defined intent actions for many common user tasks. For example, you can create intent actions to initiate applications such as the following:

. Launching the built-in web browser and supplying a URL address
. Launching the web browser and supplying a search string
. Launching the built-in Dialer application and supplying a phone number
. Launching the built-in Maps application and supplying a location
. Launching Google Street View and supplying a location
. Launching the built-in Camera application in still or video mode
. Launching a ringtone picker
. Recording a ሶዑንድ

Here is an example of how to create a simple intent with a predefined action(ACTION_VIEW) to launch the web browser with a specific URL:
Uri address = Uri.parse(“http://www.google.com”);
Intent surf = new Intent(Intent.ACTION_VIEW, address);
startActivity(surf);
This example shows an intent that has been created with an action and some data.The action, in this case, is to view something. The data is a uniform resource identifier (URI), which identifies the location of the resource to view.
For this example, the browser’s activity then starts and comes into foreground, causing the original calling activity to pause in the background. When the user finishes with the browser and clicks the Back button, the original activity resumes.

Applications may also create their own intent types and allow other applications to call them, allowing for tightly integrated application suites.

How to pass Information with Intents

We can use Intents to pass data between activities.We can use an intent in this way by including additional data, called extras, within the intent.To package extra pieces of data along with an intent, you use the putExtra() method with the appropriate type of object you want to include. The Android programming
convention forintent extras is to name each one with the package prefix( for example, com.android. johnson.NameOfExtra).

For example, the following intent includes an extra piece of information, the current game level, which is an integer:

Intent intent = new Intent(getApplicationContext(), HelpActivity.class);
intent.putExtra(“com.android.johnson.LEVEL”, 23);
startActivity(intent);
When the HelpActivity class launches, the getIntent() method can be used to retrieve the intent. Then the extra information can be extracted using the appropriate methods. Here’s an example:

Intent callingIntent = getIntent();
int helpLevel = callingIntent.getIntExtra(“com.android.johnson.LEVEL”, 1);
This little piece of information could be used to give special Help hints, based on the level.For the parent activity that launched a subactivity using the startActivityForResult() method, the result will be passed in as a parameter to the onActivityResult() method with an Intent parameter. The intent data can then be extracted and used by the parent activity.

How to launch Activities in Android

There are a number of ways to launch an activity, these are as under:

(1) Designating a launch activity in the manifest file
(2) Launching an activity using the application context
(3) Launching a child activity from a parent activity for a result

How to Access Other Application Functionality by using Contexts

In Android with the help of application context you can do alot , an application context allows you to the following

Launch Activity instances
Retrieve assets packaged with the application
Request a system-level service provider (for example, location service)
Manage private application files, directories, and databases
Inspect and enforce application permissions

How to access Application Preferences in Android

Android provides you to retrieve shared application preferences by using the getSharedPreferences() method of the application context. You can use the SharedPreferences class to save simple application data, such as configuration settings.

You can give each SharedPreferences object a name, allowing you can organize preferences into categories or store preferences all together in one large set.

For example, you might want to keep track of each user’s name and some simple game state information, such as whether the user has credits left to play. The given below code creates a set of shared preferences called gampre and saves a few such preferences:

SharedPreferences settings = getSharedPreferences(“gampre”, MODE_PRIVATE);
SharedPreferences.Editor prefEditor = settings.edit();
prefEditor.putString(“UserName”, “Spunky”);
prefEditor.putBoolean(“HasCredits”, true);
prefEditor.commit();

Now to retrieve preference settings, you simply retrieve SharedPreferences and read the desired values back out:

SharedPreferences settings = getSharedPreferences(“gampre”, MODE_PRIVATE);
String userName = settings.getString(“UserName”, “Chippy Jr. (Default)”);

Useful android SDK tools and utilities

There are a number of tools and a number of other special-purpose utilities that are included with the Android SDK:

Their detail is given below:

Android Hierarchy Viewer—Allows developers to inspect application user interface components such as View Properties while the application is running.

Draw 9-Patch tool—Helps developers design stretchable PNG files.

AIDL Compiler—Helps developers create remote interfaces to facilitate interprocess
communication (IPC) on the Android platform.

mksdcard command-line utility—Allows developers to create stand-alone SD
card images for use within AVDs and the emulator.

What are the Limitations of android emulator?

The Android emulator is a convenient tool to develop the application without a real handset , but it has many limitations which are as under:

(1) The emulator is not a device. It simulates general handset behavior, not specific hardware implementations.

(2)Sensor data, such as satellite location information, battery and power settings, and network connectivity, are all simulated using your computer.

(3)Peripherals such as camera hardware are not fully functional.

(4)Phone calls cannot be placed or received but are simulated. SMS messages are also simulated and do not use a real network.

(5)No USB or Bluetooth support is available.

(6)Using Android emulator is not a substitute for testing on a true target handset or device.

How to Take Screen Capture with android emulator

You can also take screen shot in android but the screenshot feature is particularly useful when used with true handsets. To take a screen capture, follow these steps:

1. In DDMS, choose the device (or emulator) you want a screenshot of.

2. On that device or emulator, make sure you have the screen you want, navigate to it, if necessary.

3. Choose the multicolored square picture icon to take a screen capture.

This launches a capture screen dialog.

4. Within the capture screen, click Save to save the screenshot to your local hard drive.

How to simulate an Incoming SMS to an android Emulator

You can simulate incoming SMS messages by using the DDMS Emulator DDMS (see
Figure below). You send an SMS much as you initiate a voice call.

How to simulate an Incoming Call to an android Emulator

To simulate an incoming call to an emulator running on your machine, follow these
steps:
1. In DDMS, choose the emulator you want to call.
2. On the Emulator Control tab, input the incoming phone number (for example,
5551212) in the Telephony Actions section.
3. Select the Voice radio button.
4. Click the Call button.
5. In the emulator, you should see an incoming call. Answer the call by clicking
the Send button in the emulator.
6. End the call at any time by clicking the End button in the emulator or by clicking the Hang Up button on the DDMS Emulator Control tab.

Google introduces two step verification to improve the security

If you’re a Gmail user and using other great web services that Google Offers you might be concerned about your privacy and safety, but now Google decided to increase its security and has introduced with two-step verification for its users.

the above picture shows the two step verification.

Hence finished your privacy concerns.

If you’re concerned that one can get your login details and access your Google information, the two-step verification might be the right thing for you. In order to log in with two-step verification, you have to type your login details and after that, you need to type a special code that is sent to you as a SMS.

How to Browse the Android File System

You can use the DDMS File Explorer to browse files and directories on the emulator or a device. You can copy files between the Android file system and your development machine by using the push and pull icons.

You can also delete files and directories by using the minus button or just pressing Delete. There is no confirmation for this Delete operation, nor can it be undone.

How to Manage Tasks in Android

The top-left corner of the DDMS lists the emulators and handsets currently connected. You can select individual instances and inspect processes and threads. You can inspect threads by clicking on the device process you are interested in—for example,com.androidbook.droid1—and clicking the Update Threads button.You can also prompt garbage collection on a process and then view the heap updates by clicking the green cylinder button. Finally, you can stop a process by clicking the button that resembles a stop sign .

READ MORE » How to Manage Tasks in Android

iMovie Application for iPhone 4

Apple's iMovie app enables you to turn your videos into mini masterpieces right on the iPhone 4 then also you can upload them to YouTube.

READ MORE » iMovie Application for iPhone 4

Fring a video chat Application for Iphone and android

The built in face time functionality in Iphone works only with Wi-fi network , but if you don't have wi-fi network then feel free and install fring application for video chat with your lovers , similarly this application can also be installed on smart phone running android OS.

ILight LED application for android

iLight LED is the best android application for finding anything in the dark!

Use the super bright camera LED!

It's usefull features are given below :
1) High intensity screen light
2) Instant activation of Flashlight
3) Easy Interface

How to edit android String Resource

If you inspect the main.xml layout file of the project, you will notice that it displays
a simple layout with a single TextView control. This user interface control simply
displays a string. In this case, the string displayed is defined in the string resource
called @string/hello.
To edit the string resource called @string/hello, using the string resource editor,
follow these steps:
1. Open the strings.xml file in the resource editor.
2. Select the String called hello and note the name (hello) and value (Hello
World, DroidActivity!) shown in the resource editor.
3. Within the Value field, change the text to Hello, Dave.
4. Save the file.
If you switch to the strings.xml tab and look through the raw XML, you will notice
that two string elements are defined within a <resources> block:
<?xml version=”1.0” encoding=”utf-8”?>
<resources>
<string name=”hello”>Hello, Dave</string>
<string name=”app_name”>Droid #1</string>
</resources>
The first is the string @string/hello. The second is @string/app_name, which contains
the name label for the application. If you look at the Android manifest file
again, you will see @string/app_name used in the application configuration.

How to edit Resource Files of android project

Most Android application resources are stored under the /res subdirectory of the
project. The following subdirectories are also available:
. /drawable-ldpi, /drawable-hdpi, /drawable-mdpi—These subdirectories
store graphics and drawable resource files for different screen densities and
resolutions. If you browse through these directories using the Eclipse Project
Explorer, you will find the icon.png graphics file in each one; this is your
application’s icon. You’ll learn more about the difference between these directories
in Hour 20, “Developing for Different Devices.”

. /layout—This subdirectory stores user interface layout files. Within this subdirectory
you will find the main.xml screen layout file that defines the user
interface for the default activity.

. /values—This subdirectory organizes the various types of resources, such as
text strings, color values, and other primitive types. Here you find the
strings.xml resource file, which contains all the resource strings used by the
application.
If you double-click on any of resource files, the resource editor will launch.
Remember, you can always edit the XML directly.

How to edit android manifest file

Now let’s edit the Android manifest file. One setting you’re going to want to know
about is the debuggable attribute. You will not be able to debug your application
until you set this value, so follow these steps:
1. Open the AndroidManifest.xml file in the resource editor.
2. Navigate to the Application tab.
3. Pull down the drop-down for the debuggable attribute and choose true.
4. Save the manifest file.
If you switch to the AndroidManifest.xml tab and look through the XML, you will
notice that the application tag now has the debuggable attribute:
android:debuggable=”true”

Latest Television

Toshiba 55HT1U: This "basic" 55-inch 120 Hz LCD TV can be had for $999, which is a good price for a 55-inch LCD TV. This is a non LED model and while we haven't been too enthused about Toshiba's offerings in the recent past, if you're not a stickler for the best picture in the world, the 55HT1U appears to be a reasonable deal. However, we can't tell you if it's any better than the Vizio E550VL, which offers similar specs for the same price. (We gave the Vizio 2.5 stars in our full review of that set).

Panasonic TC-P50CR: We've noticed that a lot of folks have been looking at this 50-inch 720p plasma from Panasonic. That's because it can be had for as low as $600. While it doesn't offer 1080p, this would certainly make for a decent bedroom set (or would be fine for the playroom for the kids). Unless you're using a computer with your TV, you just won't notice much difference between 720p and 1080p, particularly if you're watching from a reasonable distance.

Samsung PN50C490: This is a 50-inch 720p 3DTV that goes for around $800. It's just not going to give you great picture quality but for someone looking at a second set for a bedroom or playroom that has 3D capabilities, this has some appeal at this price point.

Vizio Razor M470NV: This 47-inch LED-backlit LCD TV with Vizio's Internet app (it's a "connected" TV) is priced around $999 (without shipping), which is right about the lowest price you'll see for an LED backlit TV at this size and break that magic $1,000 barrier. While we haven't reviewed this model, higher-end models like the Vizio XVT3SV series have done well in our reviews lately. Note: The step-up Vizio M550NV, a 55-inch model with the same features, retails for around $1,350.

Samsung LN40C530: This 40-Inch 1080p LCD TV is 60Hz model (as opposed to 120HZ), but it looks nice cosmetically and only costs $549. We haven't reviewed it but the user opinions are very favorable and it seems well suited for bedroom or playroom duty.

Search this blog

Posts

Categories

My other blogs

Use ful links

Recent Visitors