Bill Osuch - Random geek notes

BizTalk–Mapping a NACHA file using the Flat File Mapping Wizard and preserving header information

2012-04-20T14:50:46-06:00:00

In a previous post I demonstrated how to use the Flat File Mapping Wizard to map a NACHA financial file, and at the end I said I’d follow up with a post on setting up the pipeline and preserving the header information. Well, I totally forgot about that until someone asked where the post was, so here it is…

Begin by creating the three schemas as shown in the previous post. Add a pipeline to the project, and drag the Flat file disassembler component from the toolbox to the Disassemble stage. Right-click on the component and display the Properties, and configure them as follows:

Document schema: NACHA_Body
Header schema: NACHA_Header
Preserve header: True
Trailer schema: NACHA_Trailer

Now, you’d think that setting Preserve header to True means you’d get the header added to each file, right? Nope! It’s merely added to the context collection of each message. You can see this for yourself by deploying the solution, creating a send a receive port (making sure your send port has the proper filter on it, since we’re not using an orchestration yet), stopping the send port, and dropping the test file in. The messages will be suspended, so you can view the FlatFileHeaderDocument context property:

So we need to figure out a way to create a message that has the header attached. The first step will be to create a new schema. Remember, we don’t have a single schema that includes both the header and the body. Create a new schema that has all the elements in both the header and the body schemas. This is just going to be used for regular old xml, so you don’t need to worry about delimiter, positions, etc. Call it NACHA_Full.xsd; it should look something like this:

Next we’ll create an orchestration that receives the body message, constructs a new header message by extracting the header from the context properties, and maps both of those to our new schema. Create the schema, add the send and receive ports and shapes, then add a Construct Message shape with a Message Assignment shape inside of it, and finally add another Construct Message shape with a Transform inside of it, so you have something like this:

Now let’s create the messages and variables:

Message: Body_Input – NACHA_Body message type
Message: Full_Output – NACHA_Full message type
Message: Header_Input – NACHA_Header message type
Variable: HeaderString – System.String
Variable: HeaderXML – System.Xml.XmlDocument

Now we’ll add the code to generate the Header_Input message. Paste this into the Message Assignment shape:

//Grab the flat file header into a string variable
HeaderString = Body_Input(XMLNORM.FlatFileHeaderDocument);

//Load HeaderString into the XML document
HeaderXML = new System.Xml.XmlDocument();
HeaderXML.LoadXml(HeaderString);

//Assign the XML to the Header message
Header_Input = HeaderXML;

The last step in the orchestration is to configure the map. Double click the Transform shape and create a new map. This map will have two inputs, so select both Header_Input and Body_Input as the Source, and Full_Output as the destination. Click OK, and the new map should open. Use a Mass Copy to join each record, as shown:

Build and Deploy, configure the Orchestration and test it. If everything works correctly, you should again have two messages, just as in the previous post, but this time they will have the header information included.

Technorati Tags: BizTalk

BizTalk–Mapping repeating EDI segments using a Table Looping functoid

2012-03-29T08:07:56-06:00:00

BizTalk’s HIPAA X12 schemas have several repeating date/time segments in them, where the XML winds up looking something like this:

<DTM_StatementDate>
<DTM01_DateTimeQualifier>232</DTM01_DateTimeQualifier>
<DTM02_ClaimDate>20120301</DTM02_ClaimDate>
</DTM_StatementDate>
<DTM_StatementDate>
<DTM01_DateTimeQualifier>233</DTM01_DateTimeQualifier>
<DTM02_ClaimDate>20120302</DTM02_ClaimDate>
</DTM_StatementDate>

The corresponding EDI segments would look like this:

DTM*232*20120301~
DTM*233*20120302~

The DateTimeQualifier element indicates whether it’s the start date or end date – 232 for start, 233 for end. So in this example (an X12 835) we’re saying the statement starts on 3/1/2012 and ends on 3/2/2012.

When you’re mapping from some other data format, many times your start and end dates will be within the same node, like this:

<StatementDates>
<Begin>20120301</Begin>
<End>20120302</End>
</StatementDates>

So how do you map from that and create two repeating segments in your destination map? You could connect both the <Begin> and <End> nodes to a looping functoid, and connect its output to <DTM_StatementDate>, then connect both <Begin> and <End> to <DTM_StatementDate> … this would give you two repeating segments, each with the correct date, but how to add the correct qualifier? The answer is the Table Looping Functoid!

To test this, let’s create a simplified schema that just contains the date fields we’re mapping. First, create your input schema:

And your output schema:

Now create a map that uses these two schemas, and drag a Table Looping functoid onto it. The first input parameter configures the scope (or how many times the records will loop), so drag a link from the StatementDates node over to the functoid. Yes, StatementDates only appears once, so this would make it seem like it would only loop once, but you’ll see in just a minute.

The second parameter in the functoid is the number of columns in the output table. We want to fill two fields, so just set this to 2.

Now drag the Begin and End nodes over to the functoid.

Finally, we want to add the constant values for DateTimeQualifier, so add a value of 232 and another of 233. When all your inputs are configured, it should look like this:

Now we’ll configure the output table. Click on the Table Looping Grid, and configure it to look like this:

Microsoft’s description of this functoid says “The Table Looping functoid repeats with the looping record it is connected to. Within each iteration, it loops once per row in the table looping grid, producing multiple output loops.” So here we will loop (# of <StatementDates> nodes) * (Rows in the table), or 2 times.

Drag two Table Extractor functoids onto the map; these are what are going to pull the data we want out of the table. The first input to each of these will be the output of the TableLooping functoid, and the second input will be the row number to pull from. So the functoid connected to <DTM01_DateTimeQualifier> will look like this:

Connect these two functoids to the two nodes we want to populate, and connect another output from the Table Looping functoid to the <DTM_StatementDate> record. You should have a map that looks something like this:

Create some sample xml, use it as the TestMap Input Instance, and you should get a result like the XML at the top of this post.

Technorati Tags: BizTalk, EDI, Mapping

Android–Setting up a Kindle Fire emulator

2012-03-13T14:08:00-06:00:00

Developing for the Kindle Fire is pretty much the same as developing for any other Android device (aside from Amazon’s long review process…). Amazon’s developer FAQ lists most everything you need to know, but I’ve ~~stolen~~ summarized it here:

Will my app work on Kindle Fire?
For your app to work on Kindle Fire, it needs to be compatible with the device's specifications. At a high level, it must be optimized for non-Google Mobile Services (GMS) Android 2.3.4 (Gingerbread) and a 7" screen with a resolution of 1024 x 600. Your manifest should specify support for large screens. Your app cannot require a gyroscope, camera, WAN module, Bluetooth, microphone, GPS, or micro-SD to function. In addition, your app must not be a theme or wallpaper that manipulates the user interface of the device or customize the lockscreen.

We also recommend that you test your app on your own and submit an update if you discover any problems. It is possible to configure a standard Android emulator to simulate the Kindle Fire device platform. You should configure your emulator with the following characteristics:

*Width: 600px
*Height: 1024px
Abstracted LCD Density: 169
Target: Android 2.3.4 - API Level 10
RAM: 512 MB

*Note: The device will reserve 20px to display a soft key menu, making the effective portrait resolution 1004px high x 600px wide and the effective landscape resolution 580px high x 1024px wide.

What are the dimensions of the status bar (time, battery, signal strength, etc.) on Kindle Fire?
The status bar is 40px high.

My app requires access to Google Mobile Services. Will it work on Kindle Fire?
Apps that run on Kindle Fire do not currently have access to Google Mobile Services (GMS). If your app currently requires access to GMS apps or services, we recommend that you either remove the features that require these services or modify them to degrade gracefully when invoked (e.g. with an error message such as "This feature is not currently available on this device").

My app uses Google's in-app purchasing technology. How can I make it work on Kindle Fire?
Because Google's in-app purchasing technology requires access to Google Mobile Services, it will not work on Kindle Fire. We are working on a solution that will let you sell digital content in your apps using Amazon's merchandising and payments technology. Our solution is currently in Beta and available by invitation only. If you would like to join the waiting list for the Beta, please complete and submit this form, and we will follow up with more information as soon as possible.

Can I write to the internal SD card on Kindle Fire?
Using getExternalStorageDirectory() will enable you to write to the internal SD card on Kindle Fire.

What specific features does Kindle Fire support?
Kindle Fire supports the features in the following list. To ensure your app is compatible with Kindle Fire, it should only use features found in this list.

Type	Descriptor	Comment
Sensors	android.hardware.sensor.accelerometer	Your app requires an accelerometer.
Sensors	android.hardware.sensor.light	Your app requires a light sensor.
Screen	android.hardware.screen.landscape	Your app requires landscape mode.
Screen	android.hardware.screen.portrait	Your app requires portrait mode.
Touchscreen	android.hardware.touchscreen	Your app requires touchscreen capabilities that are more interactive than basic touch events.
Touchscreen	android.hardware.touchscreen.multitouch	Your app requires basic two-point multi-touch capabilities.
Touchscreen	android.hardware.touchscreen.multitouch.distinct	Your app requires the ability to track two points fully independently.
USB	android.hardware.usb.accessory	Your app requires that the device or the app itself behave as a USB device (and connects to USB hosts).
Wi-Fi	android.hardware.wifi	Your app requires 802.11b/g networking.

How should I configure the supports-screens element for compatibility with Kindle Fire?
To ensure your app is compatible with Kindle Fire, specify <supports-screen android:largeScreens="true"/> in your manifest file.

Is it possible to make the soft key menu on Kindle Fire visible at all times instead of partially hidden?
To keep the menu bar present at all times, remove any code in the activities that enables full screen mode. The soft key bar at the bottom will then be visible at all times. Sample code to remove: getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);

Is the disable_keyguard permission supported on Kindle Fire? If my app customizes the lockscreen/attempts to disable the keyguard during use, will it be compatible with Kindle Fire?
Kindle Fire does not support apps that contain disable_keyguard permissions or customize the lockscreen.

I have set up an emulator per the specification in the Kindle Fire FAQ, but the screen is being recognized as an x-large screen instead of a large screen, and loading assets accordingly. How can I fix this?
The Android emulator seems to be misreporting the screen size as x-large instead of large with our standard emulator configuration. To override the configuration, complete the following on your activity onCreate method (before loading layouts or anything else):

final Configuration config = new Configuration(context.getResources().getConfiguration());
config.screenLayout = (config.screenLayout & Configuration.SCREENLAYOUT_LONG_MASK) + Configuration.SCREENLAYOUT_SIZE_LARGE;
context.getResources().updateConfiguration(context.getResources().getConfiguration(), context.getResources().getDisplayMetrics());

This will ensure the emulator configuration properly uses the large screen size and loads the appropriate assets.

Technorati Tags: Android, Kindle

BizTalk 2010 EDI batching–using an external release trigger

2012-02-27T15:04:35-06:00:00

In an earlier post I showed you how to implement basic EDI batching, releasing the batch every time 3 messages were waiting. In the real world, you’re probably going to have some other criteria for releasing the batch; in our case a back-end system notifies BizTalk when all HIPAA 837 claims in a single file are ready to be sent.

The MSDN page for this process is actually very easy to follow, but I’ll summarize it here.

First, you’ll set up a new receive port and location to receive the trigger file. For this example, create a new folder (in the same location as the Input, Fabrikam and Contoso folders) called Trigger. Configure the receive port with a transport type of FILE, select BatchControlMessageRecvPipeline for the Receive pipeline.

Create a new .xml file and paste the xml information from the MSDN page above. You’ll need to modify it for your specific party, batch and agreement names; mine looks like this when finished:

<?xml version="1.0" encoding="utf-8"?>
<ControlMessage xmlns="http://SQLControlMessage.IssueSelect">
<PAM_Control xmlns="http://SQLControlMessage.IssueSelect">
    <DestinationParty></DestinationParty>
    <EdiMessageType>0</EdiMessageType>
    <ActionType>EdiBatchOverride</ActionType>
    <ActionDateTime>2012-02-02T14:30:00.000</ActionDateTime>
    <UsedOnce>0</UsedOnce>
    <BatchId>4</BatchId>
    <BatchName>Invoices for Contoso</BatchName>
    <DestinationPartyName>Contoso</DestinationPartyName>
    <SenderPartyName>ANCILLARY CARE SERVICES, INC.</SenderPartyName>
    <AgreementName>Contoso Purchase Order</AgreementName>
    <ReceiverPartyNameType>Contoso</ReceiverPartyNameType>
    <ToBeBatched>1</ToBeBatched>
</PAM_Control>
</ControlMessage>

(Note that the DestinationParty node can be empty.)

Finally, open up the party agreement, go to the <your party> –> Contoso tab, and click Batch Configuration. Stop the batch if necessary, and in the release section, switch from Maximum number of transaction sets to External release trigger. Click Apply, then start the batch. Restart the host instance.

To test, drop 4 copies of Contoso’s xml purchase order file to the input directory. Switch over to the Contoso folder (or wherever you have their send port pointed to) and you shouldn’t see any output yet. Remember, you had originally configured it to batch after only 3 messages. Now, drop the trigger xml file to the Trigger directory you just created, and you should see a new batch message dropped. Open it and it should have 4 individual ST/SE sections, each with the appropriate data.

Technorati Tags: BizTalk, EDI

Android tutorial–Adding images to your custom multi-line ListView

2012-02-24T15:45:47-06:00:00

In a previous post I showed how to create a custom Android ListView that was bound to an ArrayList. I've had a few people ask how to include images in the ListView, so here it is. We’ll do this by adding an ImageView to the repeating layout (each row of data) and populating it at the same time the name and other information are populated.

First, start with a working version of the previous tutorial. You can download the full Eclipse file here: ListViewBlogPost.zip

The first thing we're going to do is change the layout file. This isn't mandatory, but I want the picture to be to the left of the text, which wouldn't be possible in a linear layout. Replace the xml in custom_row_view.xml with this:

<RelativeLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent">
   <ImageView
      android:id="@+id/photo"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:paddingRight="15dp"
      android:paddingTop="10dp" />
   <TextView android:id="@+id/name"
      android:textSize="14sp"
      android:textStyle="bold"
      android:textColor="#FFFF00"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_toRightOf="@id/photo"/>
   <TextView android:id="@+id/cityState"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_below="@id/name"
      android:layout_toRightOf="@id/photo" />
   <TextView android:id="@+id/phone"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_below="@id/cityState"
      android:layout_toRightOf="@id/photo" />
</RelativeLayout>

Next you'll need to drop your images into the res/drawable directory. In real life you'd want to drop different size images into drawable-hdpi, drawable-ldpi and drawable-mdpi, but just putting them in the one directory is good enough for this example.

Now, add a get and set to the SearchResults class to allow you to set the image number for each item:

private int imageNumber = 0;

public void setImageNumber(int imageNumber) {
this.imageNumber = imageNumber;
}
public int getImageNumber() {
return imageNumber;
}

Next you'll modify the MyCustomBaseAdapter.java file. First add an Integer array with a list of your image names:

private Integer[] imgid = {
    R.drawable.smiley1a,
    R.drawable.smiley2a,
    R.drawable.smiley3a
};

Then change the ViewHolder class (the new code is in bold):

static class ViewHolder {
    TextView txtName;
    TextView txtCityState;
    TextView txtPhone;
    ImageView imgPhoto;
}

And finally the getView method:

public View getView(int position, View convertView, ViewGroup parent) {
    ViewHolder holder;
    if (convertView == null) {
        convertView = mInflater.inflate(R.layout.custom_row_view, null);
        holder = new ViewHolder();
        holder.txtName = (TextView) convertView.findViewById(R.id.name);
        holder.txtCityState = (TextView) convertView.findViewById(R.id.cityState);
        holder.txtPhone = (TextView) convertView.findViewById(R.id.phone);
        holder.imgPhoto = (ImageView) convertView.findViewById(R.id.photo);

        convertView.setTag(holder);
    } else {
        holder = (ViewHolder) convertView.getTag();
    }
        holder.txtName.setText(searchArrayList.get(position).getName());
        holder.txtCityState.setText(searchArrayList.get(position).getCityState());
        holder.txtPhone.setText(searchArrayList.get(position).getPhone());
        holder.imgPhoto.setImageResource(imgid[searchArrayList.get(position).getImageNumber() - 1]);

        return convertView;
}

Notice that all we’re doing there is setting the image resource to one of the items in the imgid array.

Finally, set the image number for each row in the ListView in the GetSearchResults method of your main activity:

private ArrayList<SearchResults> GetSearchResults(){
    ArrayList<SearchResults> results = new ArrayList<SearchResults>();

    SearchResults sr1 = new SearchResults();
    sr1.setName("John Smith");
    sr1.setCityState("Dallas, TX");
    sr1.setPhone("214-555-1234");
    sr1.setImageNumber(1);
    results.add(sr1);

    sr1 = new SearchResults();
    sr1.setName("Jane Doe");
    sr1.setCityState("Atlanta, GA");
    sr1.setPhone("469-555-2587");
    sr1.setImageNumber(2);
    results.add(sr1);

    sr1 = new SearchResults();
    sr1.setName("Steve Young");
    sr1.setCityState("Miami, FL");
    sr1.setPhone("305-555-7895");
    sr1.setImageNumber(3);
    results.add(sr1);

    return results;
}

Fire up the emulator, and it should look something like this:

Of course, there are lots of other ways of populating the ImageView in each row, but once you understand the basics it should be easy to change.

You can download the full Eclipse project at: ListViewImagesBlogPost.zip

Technorati Tags: Android

BizTalk 2006 & 2009 hotfix for EDI leap year date errors

2012-02-23T13:10:43-06:00:00

Microsoft has released a hotfix to fix a date problem in BizTalk Server 2006 R2 & 2009 when processing EDI files where a data element contains a leap date. BizTalk Server 2006 and 2010 are not affected. This issue occurs because the EDI interchange cannot validate a data element that contains a leap date value, such as "20120229".

This issue can be resolved by either installing the BizTalk Server 2009 cumulative update package 1 (if you’re running 2009…) or the hotfix at the top of KB article 2435900 (if you’re running 2006 R2).

Technorati Tags: BizTalk, EDI

Book Review: Kindle Fire: Out Of The Box (O’Reilly)

2012-02-21T12:15:19-06:00:00

The Kindle Fire, like a lot of devices these days, does not come with a user manual. Kindle Fire: Out Of The Box covers the basics of setting up and using your Fire.

This 76-page book is divided into 6 chapters:

Get to Know Your Kindle Fire
Set Up Your Fire
Books, Newsstand, and Docs
Music and Video
Apps
Web and Email

The book is loaded with detailed, annotated screen shots, which makes it easy to figure out exactly what you should be seeing on your Kindle's screen. However, this comes at a price - the pdf file is 21 megs in size, which might make it difficult if you're wanting to email it to your Kindle.

The chapters on books, music/video and apps are very Amazon-centric, but that's because the Fire is designed primarily as a device for consuming Amazon's media rather than as a generic Android tablet. However, there are instructions for loading media via USB or Amazon's Cloud Drive. Also, there are some good instructions on some of the available options you have while reading a book - changing the font and typeface, highlighting and adding notes, and using the built-in dictionary features.

The Apps chapter is by far the smallest; take out the screen shots and there's only a single page of text. This is where I have my only real gripe with the book - I would have liked to have seen something about how to determine how much of the Fire's storage space your apps (and music, videos, etc., for that matter) are taking up.

The Web and Email chapter covers the basics of browsing and setting up your email client, but if you use an email provider other than one of the four included presets (Gmail, Yahoo, Hotmail, and AOL) the setup instructions are pretty much "contact your administrator".

This book will save the average user many Google searches looking for answers to basic questions. While you're not going to find any in-depth technical information, I wouldn't hesitate to give it to my parents if they got a new Kindle Fire. O'Reilly has what appears to be a more detailed book coming up called "Kindle Fire: The Missing Manual"; I'll be curious to see what additional information it contains.

Disclaimer: I received a free copy of this e-book as part of O’Reilly’s Blogger Review Program.

Technorati Tags: Review, Kindle, Android

BizTalk 2010 EDI Batching Tutorial

2012-02-16T15:04:56-06:00:00

In two previous posts I talked about party configuration and routing of EDI messages:

Basic Party Resolution in BizTalk 2010
EDI Party Resolution (& trading partners) in BizTalk 2010

In this post I’ll build off of those examples and set up EDI batching so that we can deliver more than one EDI 810 invoice per file. You’ll need to have worked through the previous two posts to have your BizTalk application ready to follow along with these steps.

First, change the File name: of the Contoso Send Port to “Unbatched - %MessageID%.txt” (no quotes, of course).

Next, we’ll create a new Receive Location to pick up the unbatched messages and mark them for batching. (For more information on how this works, read up on the BatchMarker pipeline component at this MSDN link) Create a Receive Port called InvoicesToBatch, and a Receive Location called InvoicesToBatch_FILE. The receive folder should be the same as the folder used by the Contoso Send Port. Set the File mask: to “Unbatched*.txt”, and choose EdiReceive for the Receive pipeline:.

Now let’s configure the batching properties of the Contoso Purchase Order agreement. Click on the My Company –> Contoso tab, then Batch Configuration. For the Batch name: enter “Invoices for Contoso”. Move to the Filter section and add the following filter:

BTS.ReceivePortName == InvoicesToBatch And
BTS.MessageType == http://schemas.microsoft.com/BizTalk/EDI/X12/2006#X12_00401_810

In the Release section, choose Maximum number of transaction sets in, set the drop-down to Interchange: and enter 3. Finally, click Start immediately in the Activation section

Now we need a Send Port where we can drop the batched file. Create a new Send Port called BatchedInvoicesForContoso_FILE, pointing at the same directory as the Contoso Send Port, and set the File name: to “Batched - %MessageID%.txt”. Choose EdiSend for the Send pipeline: then move to the Filters tab. Create a filter that looks like this:

EDI.ToBeBatched == False And
EDI.BatchName == Invoices for Contoso And
EDI.SenderPartyName == My Company And
EDI.DestinationPartyName == Contoso

Click OK to save the Send Port.

So what all have we done here? As in the previous post, when we drop a Contoso XML file to the Input directory, it will have the Destination party set in the orchestration and an EDI 810 file will be dropped to the Send Port. The new Receive Port will grab the file, and the BatchMarker pipeline component will promote the appropriate context properties to allow the file to be batched. When 3 interchanges (ST/SE segments in this case) have gone through the batch process, the file will be written out. We’ve given it a different prefix (“Unbatched” vs. “Batched”) so it won’t be grabbed again and enter an infinite loop.

Time to test. Stop and restart the application, and restart the Host Instance. Drop a Contoso XML file to the Input directory, and switch over to the Contoso output directory. You should see a file created (starting with “Unbatched…”), and then it will disappear very quickly. Drop a second file in and the process repeats. Now go to the BizTalk Group Hub, and run a query for Running Service Instances. You should have a record for the BatchingService; double-click it to open and click on the Messages tab. In the Message Type column you should see two messages of type http://schemas.microsoft.com/BizTalk/EDI/X12/2006#X12_00401_810. Drop a third XML file into the Input directory and the batch should be released – you should see a Batched – <something>.txt file. Open it up and you should have a single ISA and GS segment, and three ST/SE groups.

Let’s say you want BizTalk to go ahead and batch the files it is currently holding, before the actual maximum number of transaction sets is released. Drop two instances of the XML file to the Input directory, then open the Contoso Purchase Order agreement and view the Batch Configuration tab. Click the Override button, and after a few moments a file should be dropped to Contoso’s output directory. Open it up and you’ll see that it contains only two interchanges.

You may want more control over when a batch is released – for example, you might want to send out a single batch every day when all of the files for a certain client have been processed. In a future post I’ll talk about using an external release trigger, to allow you to control exactly when the batch is released.

Technorati Tags: BizTalk, EDI

Some non-geek blog lovin’

2012-02-13T10:36:25-06:00:00

I promised my wife I’d link to her blog, so here it is:

Running on Veggies: Adventures in Healthy Living

Back to the geeky stuff shortly!

Technorati Tags: Other

Android–Create a ListView with rounded corners

2012-02-06T16:26:39-06:00:00

In a previous post I showed how to create a custom multi-line ListView bound to an ArrayList. Let’s make it a little more visually appealing and give each item some rounded corners.

If you followed the previous how-to you wound up with something that looked like this:

To put each ListView item (name, address & phone) into its own rounded-corner box, create a new file in your res/drawable directory called border.xml, and paste in the following code:

<shape xmlns:android="http://schemas.android.com/apk/res/android" >
    <stroke android:width="1dp" android:color="#FFFFFF" />
    <padding android:left="5dp" android:top="5dp" android:right="5dp" android:bottom="5dp" />
    <corners android:radius="8dp" />
</shape>

Then, specify the background of your LinearLayout in custom_row_view.xml:

android:background="@drawable/border"

And that’s it:

Of course, you can mess with colors, padding etc. to get the look you want, and you can apply this to just about any object in your layout.

Technorati Tags: Android