private Uri imageUri;


public void takePhoto(View view) {

    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");

    File photo = new File(Environment.getExternalStorageDirectory(),  "Pic.jpg");

    intent.putExtra(MediaStore.EXTRA_OUTPUT,

            Uri.fromFile(photo));

    imageUri = Uri.fromFile(photo);

    startActivityForResult(intent, TAKE_PICTURE);

}


@Override

public void onActivityResult(int requestCode, int resultCode, Intent data) {

    super.onActivityResult(requestCode, resultCode, data);

    switch (requestCode) {

    case TAKE_PICTURE:

        if (resultCode == Activity.RESULT_OK) {

            Uri selectedImage = imageUri;

            getContentResolver().notifyChange(selectedImage, null);

            ImageView imageView = (ImageView) findViewById(R.id.ImageView);

            ContentResolver cr = getContentResolver();

            Bitmap bitmap;

            try {

                 bitmap = android.provider.MediaStore.Images.Media

                 .getBitmap(cr, selectedImage);


                imageView.setImageBitmap(bitmap);

                Toast.makeText(this, selectedImage.toString(),

                        Toast.LENGTH_LONG).show();

            } catch (Exception e) {

                Toast.makeText(this, "Failed to load", Toast.LENGTH_SHORT)

                        .show();

                Log.e("Camera", e.toString());

            }

        }

    }

}

Look at my answer here for widgets/app.

You can use shapecount.xml

res/layout/tabicon.xml

<RelativeLayout

    android:orientation="vertical"

    android:background="@null"

    android:id="@+id/rlayout"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content" >

    <ImageView 

            android:id="@+id/icon"

            android:src="@android:drawable/ic_menu_mylocation" <!-- Just for test -->

            android:layout_margin="0dp"

            android:layout_height="wrap_content" 

            android:layout_width="wrap_content"/>


    <TextView android:layout_width="wrap_content" android:layout_height="wrap_content"

        android:text="50" android:textSize="12dp" android:textStyle="bold"  

        android:background="@drawable/shapecount"

        android:textColor="#FFFFFF"

        android:paddingLeft="3dp" android:paddingRight="3dp"

            android:layout_margin="0dp"

        android:layout_alignBottom="@+id/rlayout"

        android:id="@+id/txtCount" />


</RelativeLayout>

When creating your tab:

LayoutInflater inflater = LayoutInflater.from(this);

View view = inflater.inflate(R.layout.tabicon, null);

final TextView txtCount = (TextView) view.findViewById(R.id.txtCount);


spec = tabHost.newTabSpec("artists").setIndicator(view).setContent(intent);

Now you can use txtCount to update the number in the tab's icon. See the post I pointed out above for an example of TimerTask to test this.

You will have to arrange the layout as you wish also

출처 : http://old.wikidocs.net/mybook/6049
listView의 내용을 드래그 앤 드롭으로 순서를 변경하고 싶을 때 사용한다.

안드로이드 폰의 "Music" 앱의 playlist를 보면 아이템 드래그 앤 드롭이 가능하다는 것을 확인 할 수 있다. 다만 안드로이드 기본 API로 제공되지 않기 때문에 직접 구현해야만 한다. 드래그 앤 드롭이 적용된 ListView예제는 안드로이드 기본 앱인 Music에서도 확인 가능하며 필자가 만든 "마이투두" 앱에서도 확인이 가능하다.

다음은 안드로이드의 Music 앱의 소스를 참고하여 만든 DndListView이다.

아래의 코드를 사용하기 위해서는 안드로이드 버전 1.5 이상부터 가능하다.

위 코드중 정상적인 컴파일을 위해서 살펴보아야 할 부분이 두군데 있다.

1. 위 코드에 다음과 같은 부분이 있다.

1. View dragger = item.findViewById(R.id.dragicon);

R.id.dragicon 이 바로 드래그를 할 대상이 되는 View가 된다.

2. 또 다음과 같은 코드가 있다.

1. int backGroundColor = mContext.getResources().getColor(R.color.dragndrop_background);

이 부분은 드래그 앤 드롭시 백그라운드 색상을 지정해 주는 부분이다.

strings.xml파일에 다음과 같은 항목을 추가해 주어야 한다.

1. <color name="dragndrop_background">#e0103010</color>

이제 드래그 앤 드롭을 구현하기 위해서 ListActivity는 어떻게 구현해야 하는지 알아보자.

아래와 같이 DragListener와 DropListener를 구현하도록 ListActivity를 만든다.

1. public class MainActivity extends ListActivity implements DragListener, DropListener {

onCreate메써드에서 드래그 앤 드롭을 사용한다는 정보를 입력한다.

1. listView = (DndListView) findViewById(android.R.id.list);
2. listView.setDragListener(this);
   listView.setDropListener(this);

그리고 다음과 같은 메써드를 구현한다.

1. public void drag(int from, int to) {
2.   // 드래그 이벤트가 발생시 구현해야 할 것들을 기술한다.
   }
3.  
4. public void drop(int fr, int to) {
5.   // 드롭 이벤트 발생시 구현해야 할 것들을 기술한다.
6. }

Activity의 레이아웃 파일은 다음과 같이 작성해야 한다.

1.     <org.pyframe.tools.view.DndListView
           android:id="@android:id/list"
           android:layout_width="fill_parent"
           android:layout_height="wrap_content"
           android:drawSelectorOnTop="false"
           android:fastScrollEnabled="true" 
           android:cacheColorHint="#00000000"
           android:layout_weight="1.0"
            />

cacheColorHint값을 주어야 드래그 앤 드롭시 선택된 아이템의 백그라운드 색상이 표시된다.

StateListDrawable drawables = new StateListDrawable();

             drawables.addState(new int[]{-android.R.attr.state_checked, -android.R.attr.state_focused },  backgroundOff);

             drawables.addState(new int[]{android.R.attr.state_checked },     backgroundOn);

             drawables.addState(new int[]{android.R.attr.state_focused },     backgroundOn);

             setBackgroundDrawable(drawables);

StateListDrawable을 어떤 뷰까지 쓸 수 있는지는 모르겠는데 일단 버튼류는 다 되는 듯 하니 참고하세요. (ButtonEx도 이걸로 바꿨음)

출처 : http://stackoverflow.com/questions/3438276/change-title-bar-text-in-android

you can Change the Title of each screen (i.e. Activity) by setting their Android:label

   <activity android:name=".Hello_World"

                  android:label="This is the Hello World Application">

   </activity>

=> Custom - Title - bar

But if you want to Customize title-bar in your way, i.e. Want to put Image icon and custom-text, then following code is running for me:

main.xml

<?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"

    >


</LinearLayout>

titlebar.xml

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

 android:layout_width="400px" 

  android:layout_height="fill_parent"

  android:orientation="horizontal">


<ImageView android:id="@+id/ImageView01" 

            android:layout_width="57px" 

            android:layout_height="wrap_content"

            android:background="@drawable/icon1">


</ImageView>


<TextView 


  android:id="@+id/myTitle" 

  android:text="This is my new title" 

  android:layout_width="fill_parent" 

  android:layout_height="fill_parent" 

  android:textColor="@color/titletextcolor"

   />

</LinearLayout>

TitleBar.java

public class TitleBar extends Activity {

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

           super.onCreate(savedInstanceState);


           final boolean customTitleSupported = requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);


           setContentView(R.layout.main);




           if ( customTitleSupported ) {

               getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.titlebar);

               }


           final TextView myTitleText = (TextView) findViewById(R.id.myTitle);

           if ( myTitleText != null ) {

               myTitleText.setText("NEW TITLE");


               // user can also set color using "Color" and then "Color value constant"

              // myTitleText.setBackgroundColor(Color.GREEN);

           }

   }

}

strings.xml

The strings.xml file is defined under the values folder.

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <string name="hello">Hello World, Set_Text_TitleBar!</string>

    <string name="app_name">Set_Text_TitleBar</string>


    <color name="titlebackgroundcolor">#3232CD</color>

    <color name="titletextcolor">#FFFF00</color>


</resources>

출처 : http://www.ibm.com/developerworks/xml/library/x-andbene1/index.html

Mobile devices and platforms boast more features and functionality with each new release, and often mere months separate significant announcements from the leading mobile vendors. The headlines are mostly about UI features (such as advanced multitouch capabilities and Adobe® Flash® technology) and hardware enhancements (such as processor speed and storage capacity). But the crucial fact remains that content is king. Content—or, more generally, data—is exchanged constantly among applications, servers, mobile devices, and users. Without being able to work with it, smartphones such as Apple's iPhone and Google's Android simply become overpriced and underperforming cell phones.

Consider the phenomenal success of social-networking platforms such as Facebook, LinkedIn, and Twitter. From a pure feature-and-function perspective, these platforms are largely pedestrian. They are popular because members and site visitors derive value from the content published there. And that content is accessed increasingly by mobile devices.

This article demonstrates the use of XML and JSON data-interchange formats on the Android platform. The source of the data for the example application is a status-update feed for a Twitter account. The feed data is available from Twitter in both XML and JSON formats. As you'll see, the programming approach to manipulating the data varies significantly between the two formats.

I suggest you have the Android SDK version 1.5 or later installed along with Eclipse to run the example code that accompanies this article. To learn more about setting up your environment, visit the Android Developers website. It is also helpful, but not required, to have an active Twitter account to follow along with the example. See Resources for relevant links.

I'll begin with a brief look at both data formats, starting with XML. If you're already familiar with XML and JSON, you can safely skip to Application opportunity: Twitter feeds to start working with them on Android.

XML: An old friend

Virtually anyone who has done programming for the enterprise, web, or mobile markets in recent years has encountered XML. It is just about everywhere you look.

An XML document has a recognizable structure: a series of elements that can optionally contain attributes and child elements. Every valid XML document begins with a declaration on the first line: <?xml version="1.0" encoding="utf-8"?>. What comes after the first line is application-dependent. The beauty of XML is that it is self-describing.

XML schemas

Although XML documents are self-describing, they must follow certain rules and guidelines. This is where the XML schema comes in. It is a document that describes the structure of a particular XML file. Such structures are often verbose and complex. (Arguably, XML's worst contribution to the IT field is the data explosion that took place once the idea of highly descriptive data structures came into fashion, fueled in part by the greatly reduced cost of disk-storage technology in the past decade.)

As these large and complex files became more the norm, the art of working on them manually was often a nonstarter for programmers and analysts. To address this issue, XML editors and validating tools became available to aid in the management of the files and the tasks relating to them, such as documentation and conversion to legacy formats.

In addition to general text data, XML can also be used to store binary data through a special set of tags known as CDATA. CDATAtags within an XML document can contain any kind of data, including other mark-up text, provided that text does not contain CDATAitself.

It's not uncommon for APIs to leverage this capability by using XML as a structure for performing request/response queries. Often the response data contains an XML structure contained within a CDATA tag. For example, an API call might request a customer record with a last name equaling Mott. When the data is found, it is packaged into an XML structure and placed within the response element, as in Listing 1:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<request>
<query>
<lastname>Mott</lastname>
<maxhits>100</maxhits>
</query>
</request>

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<response>
<returncode>200</returncode>
<query>
<lastname>Mott</lastname>
<hits>1</hits>
</query>
<data>
<![CDATA[
<contact>
<firstname>Troy</firstname>
<lastname>Mott</lastname>
<age>not telling</age>
</contact>
]]>
</data>
</response>

XML in the workplace

Today XML is the default, expected data format. Although the same data might be available in other formats too, it is a safe bet to plan on the availability of an XML structure.

Enterprise Resource Planning (ERP) packages use XML heavily for data import and export tasks. Internet news sites often make data available as Really Simple Syndication (RSS) feeds—XML documents with a predefined format that news readers are set up to process. Even word-processing applications such as OpenOffice.org and Microsoft® Office use XML.

Today's Microsoft Office documents are PKZIP-compatible files containing multiple XML documents. Each XML file shares the common declaration in the first line. As you can see in Listing 2, the attributes can be somewhat hard to follow:

 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <w:document xmlns:ve="http://schemas.openxmlformats.org/markup-compatibility/2006"
 xmlns:o="urn:schemas-microsoft-com:office:office"
 xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
 xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
 xmlns:v="urn:schemas-microsoft-com:vml"
 xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
 xmlns:w10="urn:schemas-microsoft-com:office:word"
 xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
 xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml">
 <w:body><w:p w:rsidR="00B6337C" w:rsidRDefault="00663F0E"><w:r>
 <w:t xml:space="preserve">This is a sample </w:t></w:r><w:r
 w:rsidRPr="006906EA"><w:rPr><w:i/></w:rPr><w:t>Microsoft 
 Word document</w:t></w:r><w:r><w:t xml:space="preserve"> used
 to </w:t></w:r><w:r w:rsidRPr="006906EA"><w:rPr><w:b/>
 <w:u w:val="single"/></w:rPr><w:t>demonstrate</w:t></w:r>
 <w:r><w:t xml:space="preserve"> some XML topics.</w:t></w:r>
 </w:p><w:p w:rsidR="00B14B2A" w:rsidRDefault="00B14B2A"/><w:p 
 w:rsidR="00B14B2A"w:rsidRDefault="00B14B2A"><w:r><w:rPr>
 <w:noProof/></w:rPr><w:drawing><wp:inline distT="0" distB="0" 
 distL="0" distR="0"><wp:extent cx="3276600" cy="3838575"/><wp:effectExtent
 l="19050" t="0" r="0" b="0"/><wp:docPr id="1" name="Picture 0"
 descr="frankableson.jpg"/><wp:cNvGraphicFramePr><a:graphicFrameLocks
 xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
 noChangeAspect="1"/></wp:cNvGraphicFramePr><a:graphic
 xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData
 uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic
 xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
 <pic:nvPicPr><pic:cNvPrid="0"name="frankableson.jpg"/><pic:cNvPicPr/>
 </pic:nvPicPr><pic:blipFill><a:blip r:embed="rId4"
 cstate="print"/><a:stretch><a:fillRect/></a:stretch>
 </pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/>
 <a:ext cx="3276600" cy="3838575"/></a:xfrm><a:prstGeom
 prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic>
 </a:graphicData></a:graphic></wp:inline></w:drawing>
 </w:r></w:p><w:p w:rsidR="00663F0E" w:rsidRDefault="00663F0E"/>
 <w:p w:rsidR="00CC16CE" w:rsidRDefault="00CC16CE"/><w:sectPr 
 w:rsidR="00CC16CE" w:rsidSect="00B6337C"><w:pgSz w:w="12240" w:h="15840"/>
 <w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="720" 
 w:footer="720" w:gutter="0"/><w:cols w:space="720"/><w:docGrid
 w:linePitch="360"/></w:sectPr></w:body></w:document>

XML is self-describing, but that doesn't mean that the tags are necessarily easy to decipher. This cryptic example also demonstrates the use of multiple XML namespaces, which can make XML documents even more challenging to follow without specialized tools.

XML is everywhere, but it can often be a poor choice for an Android programmer, particularly if the data structure has fallen victim to the data explosion often associated with XML structures. A resource-constrained platform such as Android, which is usually working on a cellular data network, cannot store and parse massive amounts of XML data. However, if a particular programming task requires the interchange of both text and binary data, XML can be a solid choice.

Now you'll look at an alternative data-interchange format: JSON.

Back to top

JSON: New kid on the Net

More and more Internet API providers are offering JSON as a data-format option. JSON made a name for itself in the Ajax (Asynchronous JavaScript and XML) web-programming community. Ajax technology enables web pages to update dynamically by refreshing data in selected pockets rather the entire page. Because less data is transferred—and, more important, because much less data is parsed and drawn to the browser window—an Ajax-enabled application can provide a much better user experience than a traditional web application. In fact, a well-written Ajax application can rival smart- or fat-client applications in user experience.

When an Ajax application exchanges data with a web server, it is often requesting a refresh of some kind of data, but ideally without the formatting. It is generally considered poor practice for a web server to serve up preformatted HTML. Instead, a well-written application should send data content to the browser and apply a Cascading Style Sheets (CSS) file to provide visual effects such as colors and font particulars.

Suppose an application wants to request a contact record for our mythical Mr. Mott. The application has more than one data element to send back to the browser. So how does it get packaged? In the Listing 1 example, you might use a simple request/response structure in XML. This is perfectly adequate; however, it requires that you parse each response from the server, store the data in a structure of some sort (a DOM), and then update the web-page content.

Alternatively, you can simply get some JavaScript back from the server and work directly with it. Here is a sample response from a hypothetical application responding to a query (http://<yourserver/app/searchcontact?Mott) for a man named Mott. The response is a string representation of a JavaScript object—that is, a JSON string (split into two lines here to fit this article's page width):

[{"firstname":"Troy","lastname":"Mott","age":"don't ask!"},{"firstname":"Apple seed",
   "lastname":"Mott's","age":"99"}]

Whereas XML is known for its verbosity, JSON has a reputation for being somewhat hard to read. JSON objects are constructed in a key:value pair format. The object's elements are separated by commas, and each object is contained within curly braces {}. An array of objects is contained within square brackets. This is a common approach to transferring a series of rows from a database to an array of objects in which each array element corresponds to a database row, and each property of the object represents a column of data.

Listing 3 shows an example of using this kind of object within an HTML page. For simplicity, the server communications are not included; instead, the JSON data is provided as a string variable named serverresponse.

<html>
<head>
<script language="JavaScript">
var serverresponse = "[{\"firstname\":\"Troy\",\"lastname\":\"Mott\",\"age\":\"don't
ask!\"},{\"firstname\":\"Apple seed\",\"lastname\":\"Mott's\",\"age\":\"99\"}]";
function updatepage()
{
    var contacts = eval(serverresponse );
    var i;
    var s = "Search Results:<br />";
    for (i=0;i<contacts.length;i++)
    {
        s = s + contacts[i].firstname + " " + contacts[i].lastname + "'s age is ... " 
+ contacts[i].age + "<br />";
    }
    document.getElementById("target").innerHTML = s;
}
</script>
</head>
<body>
<button onclick="updatepage();">Search for Mott</button><br />
<span id="target">&nbsp;</span>
</body>
</html>

Note that this example uses the JavaScript function named eval() to turn a string into a JavaScript array. JSON libraries are available to provide faster and more secure methods of performing this step. The approach in Listing 3 is not a best practice. I provide it here to give some context to how a JSON object can be used in an Ajax application: The JSON structure is exchanged, parsed, and manipulated by the client code.

In summary, JSON is:

• A data-interchange format.
• A means to encode JavaScript objects as strings.
• Limited to text and numeric values. Binary values are explicitly not permitted. JSON has no CDATA equivalent.
• More economical than XML in terms of data size, at the expense of readability.
• Increasingly available as an option from API providers such as Twitter.

In Listing 3 the client is a web browser running client-side scripting. Returning to this article's focus, next you'll examine the use of XML and JSON in an Android application.

Back to top

Application opportunity: Twitter feeds

Twitter has become an international force, providing updates on everything from what people are having for breakfast and how their kid's sports team is faring at the ballpark, to serious topics such as street-level updates on political revolts in closed nations or a play-by-play of an organ transplant.

The easiest way to get to get the XML and JSON documents to use with the sample code accompanying this article is through the URL http://twitter.com/statuses/user_timeline/userid.format, where userid is your own Twitter user ID and format is either XML or JSON.

You can also find a link to this page directly on your Twitter page, as in Figure 1. You can see your Twitter user ID there.

The complete feed files are very verbose, so the next two listings show only the first entry of the feed (from my own Twitter account). Listing 4 contains the XML snippet:

<?xml version="1.0" encoding="UTF-8"?>
<statuses type="array">
<status>
  <created_at>Thu Apr 29 05:25:29 +0000 2010</created_at>
  <id>13052369631</id>
  <text>Wrapping up new article on JSON for Android
 programmers...</text>
  <source><a href="http://www.linkedin.com/"rel="nofollow">
   LinkedIn</a></source>
  <truncated>false</truncated>
  <in_reply_to_status_id/>
  <in_reply_to_user_id/>
  <favorited>false</favorited>
  <in_reply_to_screen_name/>
  <user>
    <id>15221439</id>
    <name>fableson</name>
    <screen_name>fableson</screen_name>
    <location>Byram Township, NJ</location>
    <description/>

<profile_image_url>http://a3.twimg.com/profile_images/260492935
/bookcover_normal.jpg</profile_image_url>
    <url>http://msiservices.com</url>
    <protected>false</protected>
    <followers_count>52</followers_count>
    <profile_background_color>9ae4e8
    <profile_text_color>000000</profile_text_color>
    <profile_link_color>0000ff</profile_link_color>
    <profile_sidebar_fill_color>e0ff92
</profile_sidebar_fill_color>
    <profile_sidebar_border_color>87bc44
</profile_sidebar_border_color>
    <friends_count>10</friends_count>
    <created_at>Tue Jun 24 17:04:11 +0000 2008</created_at>
    <favourites_count>0</favourites_count>
    <utc_offset>-18000</utc_offset>
    <time_zone>Eastern Time (US & Canada)</time_zone>

   <profile_background_image_url>http://s.twimg.com/a/1272044617/
images/themes/theme1/bg.png</profile_background_image_url>
   
<profile_background_tile>false</profile_background_tile>
    <notifications>false</notifications>
    <geo_enabled>false</geo_enabled>

    <verified>false</verified>
    <following>false</following>
    <statuses_count>91</statuses_count>
    <lang>en</lang>
    <contributors_enabled>false</contributors_enabled>
  </user>
  <geo/>
  <coordinates/>
  <place/>
  <contributors/>
</status>
</statuses>

Listing 5 shows the same data, this time in JSON format:

[
{"in_reply_to_status_id":null,
"favorited":false,
"created_at":"Thu Apr 29 05:25:29 +0000 2010",
"in_reply_to_screen_name":null,
"geo":null,
"source":"<a href=\"http://www.linkedin.com/\" rel=\"nofollow\
          ">LinkedIn</a>",
"contributors":null,
"place":null,
"truncated":false,
"coordinates":null,
"user":
{
    "friends_count":10,
    "description":"",
    "lang":"en",
    "statuses_count":91,
    "time_zone":"Eastern Time (US & Canada)",
    "profile_link_color":"0000ff",
    "favourites_count":0,
    "created_at":"Tue Jun 24 17:04:11 +0000 2008",
    "contributors_enabled":false,
    "profile_sidebar_fill_color":"e0ff92",
    "following":null,
    "geo_enabled":false,
    "profile_background_image_url":"http://s.twimg.com/a/1272044617/images/themes
/theme1/bg.png",
    "profile_image_url":"http://a3.twimg.com/profile_images/260492935
/bookcover_normal.jpg",
    "notifications":null,
    "profile_sidebar_border_color":"87bc44",
    "url":"http://msiservices.com",
    "verified":false,
    "profile_background_tile":false,
    "screen_name":"fableson",
    "protected":false,
    "location":"Byram Township, NJ",
    "profile_background_color":"9ae4e8",
    "name":"fableson",
    "followers_count":52,
    "id":15221439,
    "utc_offset":-18000,
    "profile_text_color":"000000"
},
"in_reply_to_user_id":null,
"id":13052369631,
"text":"Wrapping up new article on JSON for Android programmers..."}
]

Notice how much extra data is included in both listings beyond the mere status update. All you need to care about is the date/time when the post was made and the text from the post itself. Next I'll show you the pertinent portions of an Android application that parses this data. The full project is available for download.

Back to top

The XMLvsJSON application

The Android application is simple. It contains full copies of the XML and JSON data feeds and gives the user the option of parsing either one. Figure 2 shows the structure of the project files within Eclipse. (View a text-only version of Figure 2.)

Figure 3 shows the application's UI prior to the selection of a parsing option:

The application UI shows two buttons, Parse XML and Parse JSON file, followed by default text. Listing 6 contains the layout for this UI, found in the main.xml file in the res/layout folder of the project:

<?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"
    >

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:gravity="center_horizontal">

<Button android:layout_width="wrap_content" android:layout_height="wrap_content"
 android:id="@+id/btnXML" android:text="Parse XML"></Button>
<Button android:layout_width="wrap_content" android:layout_height="wrap_content"
 android:id="@+id/btnJSON" android:text="Parse JSON file"></Button>
</LinearLayout>

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android" 
android:id="@+id/ScrollView01" android:layout_width="fill_parent"
android:layout_height="wrap_content">

<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="default text" 
    android:layout_gravity="center_horizontal"
    android:id="@+id/txtData" 
    />


</ScrollView>

</LinearLayout>

The Parse XML and Parse JSON file buttons are defined above a ScrollView, which in turn contains a TextView control. The idea here is that you want the user to be able to scroll through the resulting data.

Note the use of multiple LinearLayout structures. The first is a vertical alignment, and it contains both a LinearLayout with a horizontal structure and a ScrollView. The inner LinearLayout contains the two Button widgets. This layout is inflated and wired up in the onCreate() method, in Listing 7:

    Button btnXML;
    Button btnJSON;
    TextView tvData;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);


        tvData = (TextView) findViewById(R.id.txtData);
        btnXML = (Button) findViewById(R.id.btnXML);
        btnXML.setOnClickListener(new Button.OnClickListener()
        {
            public void onClick(View v)
            { 
                examineXMLFile();
            }
        });


        btnJSON = (Button) findViewById(R.id.btnJSON);
        btnJSON.setOnClickListener(new Button.OnClickListener()
        {
            public void onClick(View v)
            {
                examineJSONFile();
            }
        });

    }

The examineXMLFile() method controls the XML parsing.

Back to top

XML parsing

Parsing of XML data is often done with a SAX-style parser. With this style of parser, you set up an InputSource pointing to the source XML data and provide a handler that receives certain events as the document is "walked." Listing 8 shows the examineXMLFile()method, which takes care of the following tasks:

• Sets up the InputSource with the XML file from the raw resources
• Creates a SAXParser, associated with a handler namedtwitterFeedHandler ( in Listing 9)
• Invokes the parser and displays the results in a TextViewwidget identified in the layout file as R.id.txtData and referenced in the code as tvData
• Shows any errors, also in the TextView

void examineXMLFile()
    {
        try {
            InputSource is = new InputSource(getResources()
.openRawResource(R.raw.xmltwitter));
            // create the factory
            SAXParserFactory factory = SAXParserFactory.newInstance();
            // create a parser
            SAXParser parser = factory.newSAXParser();
            // create the reader (scanner)
            XMLReader xmlreader = parser.getXMLReader();
            // instantiate our handler
            twitterFeedHandler tfh = new twitterFeedHandler();

            // assign our handler
            xmlreader.setContentHandler(tfh);
            // perform the synchronous parse
            xmlreader.parse(is);
            // should be done... let's display our results
            tvData.setText(tfh.getResults());
        }
        catch (Exception e) {
            tvData.setText(e.getMessage());
        }
    }

Whereas examineXMLFile() sets things up, the real parsing work from the perspective of the application takes place in the handler that's implemented in the twitterFeedHandler.java file. This class, which implements the DefaultHandler interface, is inListing 9:

public class twitterFeedHandler extends DefaultHandler {

    StringBuilder sb = null;
    String ret = "";
    boolean bStore = false;
    int howMany = 0;

    twitterFeedHandler() {
    }

    String getResults()
    {
        return "XML parsed data.\nThere are [" + howMany + "] status updates\n\n" + ret;
    }
    @Override

    public void startDocument() throws SAXException {
        // initialize "list"
    }

    @Override
    public void endDocument() throws SAXException {

    }

    @Override
    public void startElement(String namespaceURI, String localName, String qName, 
Attributes atts) throws SAXException {

        try {
            if (localName.equals("status")) {
                this.sb = new StringBuilder("");
                bStore = true;
            }
            if (localName.equals("user")) {
                bStore = false;
            }
            if (localName.equals("text")) {
                this.sb = new StringBuilder("");
            }
            if (localName.equals("created_at")) {
                this.sb = new StringBuilder("");
            }
        } catch (Exception ee) {

            Log.d("error in startElement", ee.getStackTrace().toString());
        }
    }

    @Override

    public void endElement(String namespaceURI, String localName, String qName)
throws SAXException {

        if (bStore) {
            if (localName.equals("created_at")) {

                ret += "Date: " + sb.toString() + "\n"; 
                sb = new StringBuilder("");
                return;

            }

            if (localName.equals("user")) {
                bStore = true;
            }

            if (localName.equals("text")) {

                ret += "Post: " + sb.toString() + "\n\n";
                sb = new StringBuilder("");
                return;

            }


        }
        if (localName.equals("status")) {
            howMany++;
            bStore = false;
        }
    }

    @Override

    public void characters(char ch[], int start, int length) {

        if (bStore) {
            String theString = new String(ch, start, length);

            this.sb.append(theString);
        }
    }

}

Listing 9 contains some noteworthy items. The first thing to consider is that the SAX parser is an event-based parser, which means that you build the actual document as it is parsed. Events are fired whenever the document starts, the document ends, a tag starts, a tag ends, and data is found. This implies that you must define a data structure to keep the data of interest and discard the rest.

Note the StringBuilder and the appending of data, used because a particular data element can be processed across multiple reads on the InputSource. Never assume that all of the data is provided in any given call to the characters() method.

This application collects the data into a simply formatted string. An alternative example might include putting these entries into a collection class or database instead, particularly if a great deal of manipulation were to take place after the parse.

The getResults() method is custom to this class. It's used to gather the assembled representation of this data and provide it to the application. It is not part of the DefaultHandler's interface.

Figure 4 depicts the parsed XML data. (View a text-only version of Figure 4.)

Although parsing XML with the SAX parser is nontrivial in terms of building up, managing, and navigating the resulting structure, its main advantages are speed and the opportunity to reduce significantly the amount of RAM required both during and after the parsing step.

Now you'll take a look at Android's approach to parsing JSON data.

Back to top

JSON parsing

Parsing JSON data in the application starts when the user selects the JSON button. This invokes the examineJSONFile() method, in Listing 10. No additional handler class is required, because all parsing and document management take place within the Android-supplied libraries, and all JSON-related code is contained in this method.

void examineJSONFile()
    {
        try
        {
            String x = "";
            InputStream is = this.getResources().openRawResource(R.raw.jsontwitter);
            byte [] buffer = new byte[is.available()];
            while (is.read(buffer) != -1);
            String jsontext = new String(buffer);
            JSONArray entries = new JSONArray(jsontext);

            x = "JSON parsed.\nThere are [" + entries.length() + "]\n\n";

            int i;
            for (i=0;i<entries.length();i++)
            {
                JSONObject post = entries.getJSONObject(i);
                x += "------------\n";
                x += "Date:" + post.getString("created_at") + "\n";
                x += "Post:" + post.getString("text") + "\n\n";
            }
            tvData.setText(x);
        }
        catch (Exception je)
        {
            tvData.setText("Error w/file: " + je.getMessage());
        }
    }

Like the XML routine shown previously, this code reads in a file from the raw resources. The data is read into memory in its entirety, converted to a java.lang.String, and then parsed into a JSONArray. Note that a particular string can be parsed directly into an array, as in this example, or the string can be parsed into a JSONObject. Because the Twitter data is an array of objects, it makes sense to parse the entire string into an array and then access the object individually by ordinal position.

This method's flow is straightforward; once the data is parsed, the code builds up a string representation that's similar to the approach of the XML parser handler. Of interest here is that the data is managed for you; you don't need to build up additional memory structures to contain the data. Likewise, the application knows up front just how many entries are in the JSONArray (20 in this example).

Although JSON parsing is much more simple programmatically, it is not cost-free. It adds the burden of memory consumption for reading in the entire data stream before it can be worked on, and for storing all of the data. In contrast, the SAX XML approach uses only the data of interest. That caveat aside, if memory for parsing a particular JSON object is ample, this approach can be favorable for many applications, particularly if working with the DOM is of little interest.

 
출처 :  http://tigerwoods.tistory.com/23

1. ViewFlipper의 용도

ViewFlipper는 Tab과 마찬가지로 화면에 표시 가능한 여러 view가 준비되어 있을 때 화면에 현재 표시된 view를 다른 view로 전환하기 위해 사용된다.

Tab은 일반적으로 표현하려는 view간의 구분(TabWidget의 이름으로) 이 필요할 때 사용되며, ViewFlipper는 view간의 구분이 필요 없을 경우 많이 사용된다.

ViewFlipper의 사용 예로는 안드로이드 폰의 초기화면과 같은 경우가 있다.

예를 들면, 많은 어플리케이션을 인스톨한 유저는 사용하는 모든 어플리케이션에 대한 icon을 하나의 view에 표시할 수 없고, 여러 개의 view를 사용해야만 모든 icon을 표시 할 수 있다. Tab을 사용해서 여러 view를 하나씩 보여줄 수도 있지만, 모든 view는 단순한 icon의 나열임으로 굳이 view 와 view를 이름으로 구분할 필요가 없는 상황에서 Tab이름을 위한 Label을 배치하는 것은 공간의 효율적 사용이 아니다.

이럴 때 ViewFlipper를 사용하면 화면 전체를 원하는 view로 채워 넣을 수 있어 공간의 효율적인 사용이 가능하다.

하지만, 여러 view가 있는데 그 중 특정 view로 비 순차적으로 건너뛰어야 할 경우 Tab은 해당 Tab을 클릭하면 되지만, ViewFlipper는 원하는 view까지 순차적으로 flip해야 한다는 단점이 있기는 하다. (ViewFlipper도 구현에 따라 특정 view로 건너뛰게 만들 수 있으나, 그렇게 사용하려면 굳이 ViewFlipper를 사용할 이유가 적어지는 것 같다)

결국, view간의 전환을 구현하는데 Tab을 사용할지 아니면 ViewFlipper를 사용할 지는 전적으로 개발자의 몫임으로, 사용자의 입장에서 판단해서 사용자에게 최대한 편리한 UI를 제공하는 것이 중요할 것이다.

2. ViewFlipper의 구현

다음은 ViewFlipper의 클래스 상속 구조이다.

ViewFlipper를 사용했을때 앞/뒤 view로 전환을 위해서는 버튼, trackball, 방향키, 화면 터치, 흔들기 등이 사용되는데, 여기서는 일반 스마트폰의 초기 화면 같은 터치 방식을 이용해 구현해 보려고 한다.

먼저 예제를 보기 전에 몇가지 살펴볼 것이 있다.

FrameLayout의 특징

ViewFlipper가 상속하는 FrameLayout은 다른 layout과는 조금 다른 점이 있다.

바로 FrameLayout에서는 child view들이 모두 왼쪽 상단을 기준으로 겹쳐 쌓이도록 디자인 되었다는 것이다.

즉, FrameLayout에 어떤 layout을 적용 하던 child view는 항상 FrameLayout의 좌측 상단 코너를 기준으로 쌓여버린다. (layout_gravity등의 layout 관련 속성이 FrameLayout에서는 작동 안 함)

만약 하나 이상의 child view가 FrameLayout에 할당될 경우 모든 child view는 FreameLayout의 좌측 상단에 쌓이게 되고, 가장 마지막에 쌓인 child view의 크기만큼 뒤에 쌓여있는 다른 child view의 영역을 가려버린다.

그림으로 표현하면 다음과 같다. 

위의 그림은 Child View 1, 2, 3 순으로 FrameLayout에 더했을 때 일어 나는 일이다.

FrameLayout에 더해지는 모든 view는 외쪽 상단 코너를 기준점으로 정렬되고 가장 나중에 더해진 Child View 3이 전에 더해진 child view들을 모두 가려 버리는 것을 볼 수 있다.

Tab과 ViewFlipper에서는 이렇게 child view를 한곳에 포개어 놓고 보여줄 child view를 가장 상단으로 올리는 방법으로 여러 개의 view를 한 화면에 번갈아 가면서 표시한다.

그렇기 때문에 FrameLayout 내부에서 복잡한 구성의 child view를 표현하려면 다음과 같은 구조를 사용해야 한다.

(Tab, ViewFlipper 모두 FrameLayout에서 상속함으로 참고)

FrameLayout은 한번에 한 view만 표현 가능하기 때문에 child view의 layout을 "fill_parent"로

설정하면 FrameLayout을 꽉 채운 child view로 표현 할 수 있다.

OnTouchListener 인터페이스의 구현

화면에 일어나는 touch를 감지하기 위해서는 android.view.View.OnTouchListener interface를 구현하여야 한다.

OnTouchListener 인터페이스는 다음과 같은 abstract callback method를 포함 함으로 구현해 주어야 한다.

parameter:

    v - touch가 일어나고 있는 view object

    event - 현재 일어나고 있는 event

return:

     callback이 event를 처리 했으면 true, 그렇지 못했으면 false.

MotionEvent객체에는 여러 모션을 나타내는 constant가 미리 define되어 있다.

예제에서는 MotionEvent:ACTION_DOWN과 MotionEvent:ACTION_UP을 사용하는데 이는 각각 터치 시작과 터치 끝을 나타낸다.

또, MotionEvent객체는 현재 일어나는 이벤트에 대한 좌표 정보를 리턴하는 여러 메소드도 제공하는데

예제에서는 float MotionEvent:GetX()라는 이벤트가 일어나는 x좌표를 float형으로 리턴하는 메소드를 이용해 발생 이벤트를 인식한다.

Animation 리소스의 사용

안드로이드에서는 animation도 resource로 등록이 된다.

프로젝트 폴더\res\anim\ 폴더 밑에 xml형식의 문서로 저장되며, java code 에서는 AnimationUtil:loadAnimation(context, int)을 이용해 컴파일된 animation 리소스에 접근한다. ('R.anim.animation_xml_file_이름' 이용)

이 번 예제를 위해서는 다음과 같이 4개의 animation xml 문서가 사용되었다.

• push_left_in.xml: 새로운 view가 왼쪽 방향으로 밀려 들어옴.
• push_left_out.xml: 기존 view가 왼쪽 방향으로 밀려 나감.
• push_right_in.xml: 새로운 view가 오른쪽 방향으로 밀려 들어옴.
• push_right_out.xml: 기존 view가 오른쪽 방향으로 밀려 나감.

위의 xml 문서에서 사용된 주요 xml element와 attribute는 다음과 같다. 

<translate>

상하좌우 이동 animation을 지정하며. TranslateAnimation 클래스에 대응한다.

다음과 같은 4가지의 xml attribute에

• android:fromXDelta: animation시작하는 X 좌표
• android:toXDelta: 끝나는 X 좌표
• android:fromYDelta: Starting Y location.
• android:toYDelta: Ending Y location.

다음과 같은 3가지 종류의 값(value) 중 하나를 사용한다.

• -100% ~ 100%: 자기자신을 기준으로 한 위치에 대한 비율. 0%가 현재 자기 위치.
• -100%p ~ 100%p: 부모 컨테이너를 기준으로 한 위치에 대한 비율. 0%p가 현재 자기 위치.
• float값: 절대 위치를 나타냄.

<alpha>

투명함을 조정하며, AlphaAnimation 클래스에 대응한다.

다음과 같은 xml attribute를

• android:fromAlpha: animation 시작 시 투명도
• android:toAlpha: animation 완료 시 투명도

다음과 같은 값으로 설정한다.

• 0.0 ~ 1.0 (0.0이 투명, 1.0이 완전 불 투명)

추가로 위의 두 element(translate, alpha)에서 공통으로 사용되는 animation이 지속되는 시간을 나타내는 attribute는 다음과 같다.

• android:duration: Animnation이 시작돼서 끝나는 시간을 밀리 초(1/1000초) 단위로 설정함.

Java code에서 ViewFlipper 객체의 사용

Java code에서 ViewFlipper 객체 생성은 findViewById() 메소드를 사용하던가 새로운 view를 inflate 시킬 수 있다.

예제에서는 layout xml 파일 내부에 선언된 ViewFlipper element와 findViewById() 메소드를 이용해 객체를 생성한다.

예제 코드 내부에서 ViewFlipper객체가 사용할 메소드는 다음과 같다.

• View:addView(View): layout xml 문서 내부의 ViewFlipper element에 nest된 view 이외에 새로운 view를 동적으로 추가한다.
• ViewAnimator:setInAnimation(Context, int): 새로운 view가 화면에 진입시의 animation 설정
• ViewAnimator:setOutAnimation(Context, int): 기존 view가 화면에서 퇴장시의 animation 설정
• ViewAnimator:showNext(): ViewFlipper에 등록된 view중 현재 view의 다음 view를 화면에 보이게 함
  
• ViewAnimator:showPrevious(): ViewFlipper에 등록된 view중 현재 view의 전 view를 화면에 보이게 함
• ViewFlipper:setFlipInterval(int): 자동 flipping시 적용할 시간간격 (1/1000초 단위 사용)
  
• ViewFlipper:startFlipping(): 설정된 시간간격을 적용해 자동 flipping 시작 함 
  
• ViewFlipper:stopFlipping(): 자동 flipping을 정지 함

위에서 설명한 것들을 바탕으로 예제 소스를 분석해 보자.

push_left_in.xml

소스 펼치기

push_left_out.xml

소스 펼치기

push_right_in.xml

소스 펼치기

push_right_out.xml

소스 펼치기

main.xml

소스 펼치기

MyViewFlipper.java

소스 펼치기

다음은 실행 결과이다. 에뮬레이터에서는 마우스 드레그를 통해 터치 이벤트를 test가능하며, 에니메이션이 적용되어 view간의 전환이 부드럽게 이뤄짐을 볼 수 있다. 또, CheckBox를 첵크 하면 2초 간격으로 자동으로 view 가 flip 되는 것을 볼 수 있다.

                                                       프로젝트 소스 다운로드

 018_ViewFlipper Demo.zip

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">


<item android:id="@android:id/background">

    <shape>

        <corners android:radius="5dip" />

        <gradient

                android:startColor="#ff9d9e9d"

                android:centerColor="#ff5a5d5a"

                android:centerY="0.75"

                android:endColor="#ff747674"

                android:angle="270"

        />

    </shape>

</item>


<item android:id="@android:id/secondaryProgress">

    <clip>

        <shape>

            <corners android:radius="5dip" />

            <gradient

                    android:startColor="#80ffd300"

                    android:centerColor="#80ffb600"

                    android:centerY="0.75"

                    android:endColor="#a0ffcb00"

                    android:angle="270"

            />

        </shape>

    </clip>

</item>

<item

    android:id="@android:id/progress"

>

    <clip>

        <shape>

            <corners

                android:radius="5dip" />

            <gradient

                android:startColor="@color/progress_start"

                android:endColor="@color/progress_end"

                android:angle="270" />

        </shape>

    </clip>

</item>


</layer-list>

출처 : http://fanpro.springnote.com/pages/5306953

xml에 color설정하는 법

http://developer.android.com/intl/fr/guide/topics/resources/available-resources.html

res/values/colors.xml이라는 파일을 만들고 아래와 같이 지정하면 된다.

1. <?xml version="1.0" encoding="UTF-8"?>
2. <resources>         
3. <color name="dim">#77000000</color>
4. <color name="transparent">#00000000</color> 
5. </resources> 

이렇게 지정한 color는 android:textColor="@color/dim" 과 같은 식으로 사용이 가능하다.

xml에 color state list 설정하는 법

http://androidappdocs-staging.appspot.com/reference/android/content/res/ColorStateList.html

color를 xml에 지정하기 위해서는 res/color라는 폴더를 만든 후 xml파일을 생성하면 된다.

ex) res/color/font_set_a.xml 아래의 예는 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
3. <item android:state_focused="true" android:color="#cccccc" />
4. <item android:state_pressed="true" android:color="#cccccc" />
5. <item android:state_active="true" android:color="#333333" />
6. <item android:color="#333333" />
7. </selector>

이렇게 선언한 셀렉터는 "@color/font_set_a"와 같이 사용이 가능하다.

스타일 설정

위와 같이 선언한 색상들과 폰트크기등을 합쳐서 스타일을 만들 수가 있는데

res/values/styles.xml파일을 생성 후

1. <?xml version="1.0" encoding="UTF-8"?>
2. <resources>
3. <style name="font_set_a">
4. <item name="android:textColor">@color/font_set_a</item>
5. <item name="android:textSize">36px</item>
6. </style>
7. <style name="font_set_b">
8. <item name="android:textColor">@color/font_set_a</item>
9. <item name="android:textSize">24px</item>
10. </style>
11. </resources>

위와 같이 묶어서 스타일을 지정할 수 있다. 이렇게 만든 스타일은 style="@style/font_set_a"와 같은식으로 사용가능하다.

액티비티의 테마지정(1)

액티비티는 기본적으로 title과 body로 구분되는 불투명한 스타일이다.

이를 변경할 수 있는데 해당 스타일은 아래와 같으며 manifest.xml의 <activity .../> 내에 지정하면 된다.

android:theme="@android:style/Theme.NoTitleBar" 타이틀바 제거

android:theme="@android:style/Theme.NoTitleBar.Fullscreen" 타이틀바 + 인디케이터 제거

android:theme="@android:style/Theme.Translucent.NoTitleBar.Fullscreen" 타이틀바 + 인디케이터 제거 + 투명하게 설정

액티비티의 테마를 xml로 지정하기(2)

values/styles.xml에 아래와 같이 속성을 지정

1. <?xml version="1.0" encoding="UTF-8"?>
2. <resources>
3.  <style name="WebTheme" parent="android:Theme">
4.              <item name="android:windowNoTitle">true</item>
5.              <item name="android:windowFullscreen">true</item>
6.              <item name="android:windowBackground">@android:color/white</item>
7. </style>  

activity의 속성에 theme를 지정

1. android:theme="@style/WebTheme"