Tag: android

Xamarin Forms and Leveraging Autofac

I love dependency injection frameworks ever since I started using them. Specifically, I’m obsessed with using Autofac and I have a hard time developing applications unless I can use a solid DI framework like Autofac! I’ve recently been working with Xamarin and found that I wanted to use dependency injection, but some of the framework doesn’t support this well out of the box. I’ was adamant to get something going though, so I wanted to show you my way to make this work.

Disclaimer: In its current state, this is certainly a bit of a hack. I’ll explain why I’ve taken this approach though!

In your Android projects for Xamarin, any class that inherits from Activity is responsible for being created by the framework. This means where we’d usually have the luxury of passing in dependencies via a constructor and then having Autofac magically wire them up for us isn’t possible. Your constructors for these classes need to remain parameterless, and your OnCreate method is usually where your initialization for your activity will happen. We can work around that though.

My solution to this is to use a bit of a reflection hack coupled with Autofac to allow Autofac resolutions in the constructor as close as possible as to how they would normally work. A solution I wanted to avoid was a globally accessible reference to our application’s lifetime scope. I wanted to make sure that I limited the “leakage” of this not-so-great pattern to as few places as possible. With that said, I wanted to introduce a lifetime scope as a reference only to the classes that were interested in using Autofac where they’d otherwise be unable to.

  1. Make a static readonly variable in your classes that care about doing Autofac with a particular name that we can lookup via reflection. (An alternative is using an attribute to mark a static variable)
  2. After building your Autofac container and getting your scope (but prior to using it for anything), use reflection to check all types that have this static scope variable.
  3. Assign your scope to these static variables on the types that support it.
  4. In the constructors of these classes (keeping them parameterless so the framework can still do its job!), access your static scope variable and resolve the services you need

Here’s what that looks like in code!


 public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
        protected override void OnCreate(Bundle savedInstanceState)
            var builder = new ContainerBuilder();

            // TODO: add your registrations in!

            var container = builder.Build();
            var scope = container.BeginLifetimeScope();

            // the static variable i decided to use is called "_autofacHack"
            // so that it deters people from using it unless they know
            // what it's for! you could use reflection to find similar
            // fields with something like an attribute if you wanted.
            foreach (var field in GetType()
                .Select(x => x.GetField("_autofacHack", BindingFlags.NonPublic | BindingFlags.Static))
                .Where(x => x != null))
                field.SetValue(null, scope);


The class that can take advantage of this would look like the following:

public sealed class MyActivityThatNeedsDependencyInjection : Activity
    private static readonly ILifetimeScope _autofacHack;
    private readonly IMyService _theServiceWeWant;

    // NOTE: we kept the constructor PARAMETERLESS because we need to
    public MyActivityThatNeedsDependencyInjection ()
        _theServiceWeWant= _autofacHack.Resolve<IMyService>();

    protected override void OnCreate(Bundle savedInstanceState)

        // now we can use this service that we "injected"


Reading this you might think “well I don’t want to pollute my Xamarin code with variables that say _autofacHack, that’s gross”. And I don’t blame you! So this is to serve as a starting point for a greater solution, which I think is something I’ll evolve out for myself and I encourage you to do the same.

Things I’m focused on:

  • Minimize where “ugly” code is. A globally accessible scope on a static class seems like it can spread the “ugly” code to too many spots. This approach is intended to help minimize that.

    What are some next steps to make that EVEN better? Maybe an attribute so we can call it something nicer?
  • Write code that feels as close as possible to the “real” thing. Autofac usually allows us to specify services in the constructor and then automatically allows us to get the instances we need. This code is structured to be very similar, but since we’re NOT allowed to change the parameterless constructors, we resolve our services off the container there instead. And because it’s in the constructor, we can assign things to readonly variables as well which is a nice bonus.

The more implementations of this I go to use, the more I plan to refine it! How have you leveraged Autofac in your Xamarin projects?

Downtime? Time to Build!

The COVID-19 pandemic has caused many of us to stay isolated and at home, but that’s OK! I genuinely enjoy developing software and wanted to take this opportunity to focus on learning. Having some downtime has afforded me to try putting together a system that I otherwise might not have explored building.

In this article, I’ll share different aspects about an application I’m building that purposefully put me outside of my comfort zone. In my opinion, having downtime is an opportunity to learn and grow! It’s time to take advantage of that.

When the app and system is ready to showcase I’ll share more insight into what’s actually being built!

The Client Framework

The application being built was intended to run on multiple mobile platforms, so Xamarin was my choice here. I have briefly used Xamarin several years ago, but my reasons for this time through were:

  • C#, .NET, and Visual Studio support. There were many things I wanted to learn about, but I wanted to limit myself to a familiar foundation so that I could still feel that I’m making progress.
  • Supports iOS and Android right from the start. I thought it would be an interesting software design challenge to be able to build base components in a shared library and then leverage dependency injection for platform-specific components.
  • Traction. Xamarin has been around for a number of years now, and it’s only continuing to gain support. I didn’t want to focus on a platform or SDK that wasn’t getting any love.

Xamarin was easy to get setup with because of the familiar pieces, but I was pushed out of my comfort zone to learn about how certain things are handled differently on iOS and Android

I was able to learn about:

  • Android/iOS permission requests
  • The new UI controls in Xamarin (vs WPF which I’m used to)
  • More practice with async/await and UI experience
  • Different mobile API frameworks (Crashlytics, Google Analytics, user control libraries)

The Server Framework

I’ve joked with my colleagues in the past that “web isn’t my thing”, but what I really mean is that “I don’t have experience making web pages”. I’ve build many client server systems in my professional experience and hobby programming, but serving nice-looking web pages hasn’t been my strength.

For the system that I’m designing in my downtime, I need an application server. I decided to go with ASP.NET Core because I haven’t set up many ASP.NET systems before, and I don’t have experience having them hosted in the cloud. However, I do have experience with C# and Visual Studio, so again, this seemed like a good balance of trying new things with some familiar concepts to ensure I could make progress.

In short order, I was able to get a handful of application server routes setup and communicating with the client application properly. The most difficult part was truly just making sure firewall and SSH settings were configured locally, and a handful of times of cursing at my phone for not having it on WiFi (and thus not seeing the development server on my local network)!

I was able to learn about:

  • Authentication attributes (and JWT token handling)
  • Routes with query parameters
  • Serving static content as well as application requests

The Authentication Framework

This one was fun. Having a professional career in software development, one thing that scares everyone away is designing authentication and user management. Nobody wants to because it’s complex, has plenty of edge cases, and… it’s probably critical to your system working 🙂

Thankfully, Firebase saved the day. I wrote about this already, but Firebase truly made authentication and user management way more straight forward than I’m used to. The hardest parts of working with Firebase had nothing to do with Firebase and everything to do with implementing OAuth for the providers of my choosing.

Because I could use OAuth to authenticate users and have identifiable information provided via a JWT, having a simple registration and login system that mapped OAuth’d users to some sort of internal-system user identifier was trivial. All of the routes for my web application could also authenticate and control access via this same JWT! One of the scariest components about building a system became a relatively light lift.

I was able to learn about:

  • OAuth for popular providers (Google, Facebook, etc…)
  • OAuth scopes
  • JWT tokens
  • Firebase SDK from a server and client side
  • Route authentication in ASP.NET using JWTs

The Database Framework

As part of the journey for exploring unfamiliar technology in my downtime, I decided I’d like to pursue a database that wasn’t SQL-based. I was already using Firebase for authentication and Google offers an intriguing document store in Firebase that provides real-time update triggers.

Being unused to document databases (I’m much more familiar with relational databases), I spent some time trying to design my schemas that I intended to use. One thing that caught me off guard pretty quickly was that in order to modify to a list of things, I’d need to have a local copy of the list, manipulate the collection, and then push the entire structure back to replace the existing structure. This seemed like overkill what I was trying to do, but the alternative was that I could modify objects in the data store to add/remove child items, but each child item would receive another identifier object as a linking object. So a list of X things actually meant 2X things (one for the identifier, one for the entry). Again, this was overkill.

I decided to go back to familiar technology but explore a not so familiar space! I have a good deal of experience working with SQLite and MySQL from my career. What I don’t have a lot of experience with is the management and provision of a MySQL instance with availability in the cloud! Enter Amazon RDS!

Switching to Amazon RDS meant a bit of a learning curve for making sure I could host and configure an instance of MySQL in the cloud. I was able to learn about various Amazon AWS services and roles and how they play together. But once the instance was up and running, I was able to get up and running effectively.

The Tooling

I had help with this one, fortunately, from a friend and old colleague of mine Graeme Harvey. If you’ve worked with me professionally or on a hobby project, one of the things I admit pretty quickly is that I really dislike tinkering to get a configuration right. Generally this is because there’s a lot of tweaking to get something set up right, documentation to understand, and frustrating trial and error.

Source control was going to be git. I didn’t even want to consider anything else. Git is so widely used now that I didn’t see a real benefit to trying to learn a new source control system. Repository management though? BitBucket. I’m a huge fan of the Atlassian suite of products having used them professionally for many many years.

And with that said Jira for issue management. Again, I’ve used Jira professionally for many years. What I’ve never done is had my own Jira instance though! This was made very simple by Atlassian, and not being a company that’s generating big bucks I was able to get the free tier that handles all of my needs. Jira is straight up awesome for issue management and visibility into your ongoing work.

Another no-brainer for me was getting Slack setup. Slack is something I’ve used a lot professionally but like Jira, I’ve never had my own Slack instance. Simple to setup and works just like I’m used to in my career. This wasn’t really a huge requirement but working with another person provided a nice workspace for chatting about stuff we were working on.

And finally… builds. I wrote about using Circle CI to get our server builds up and running already, and to re-iterate it was extremely simple. I even have them wired up to report back to Slack when we push code up to BitBucket! Where we’re still having some fun is figuring out how to deploy our application server builds to an EC2 instance automatically. This would allow us to “release” to a branch and have production hosting of our application server get updated in the cloud!

But we’re building a mobile application in Xamarin, so we have three outputs:

  • The application server in ASP.NET
  • The Android client
  • The iOS client

Mobile app development gets interesting because what you’re actually building is intended to run on a device and not a desktop/server… And why that matters is that generally your desktop or server application will be output as a binary, but your mobile application will be some sort of package you’ll need to sign and distribute on an app store.

After some back and forth, we decided to explore App Center. If I’m being honest, this was equally as easy to setup for our iOS and Android apps using Xamarin as our server was to setup using Circle CI for builds. App Center provided a simple wizard for triggering off of our BitBucket repositories getting new commits to a branch, and the rest was done for us.

What I learned:

  • Git+BitBucket = Free git repository hosting (private if you want) and plenty of integrations
  • Jira = Free issue management and kanban board with plenty of integrations
  • Slack = Free chat workspace with plenty of integrations
  • CircleCI = Free continuous builds with integrations into ALL the other things I just mentioned 🙂
  • App Center = Free continuous builds for iOS and Android Xamarin apps with plenty of integrations!

In Summary

It’s been a couple of weeks of getting to try building out this project and setting up these different systems to go to work for me. I’ve been able to learn a lot about new or previously unexplored SDKs/technology and even learn some different facets of things I already have professional experience with.

I’m not one to sit idle… So using my downtime to learn cool things and build something has been an awesome time! I’d highly recommend that if you’re in quarantine, lockdown, or otherwise unable to really get out and do too much that you try your hand at something new! Get creative. Get learning.

Be safe and stay healthy!

Timur Kernel on 2013 Nexus 7 WiFi (flo)

Timur Kernel on 2013 Nexus 7 WiFi (flo)

Background on Timur’s Kernel

I got fed up with having a pretty crummy head unit in my 2012 Audi TT RS (named Ignantt), and decided that it was time to take matters into my own hands. Part of doing a Nexus 7 head unit install in a vehicle involves powering the tablet up with a USB on-the-go (OTG) cable and being able to not only power the device but also plug in USB devices into the tablet to use. In order to get this working, everyone seems to be relying on this kernel from Timur. As per Timur’s site:

This feature allows you to connect one or more USB slave devices to your tablet and charge it at the same time. This allows you, say, to operate an external USB DAC without the tablet ever running out of power. To use this feature you will need an “OTG charging” – or a std. OTG adapter combined with a USB-Y cable.

Right-o. So yesterday evening after work I spent almost the entire night trying to get this going (aside from eating dinner and hitting the gym). I really feel that this should have been significantly easier for me, and when I reflect on how the whole thing went down, the actual process IS actually easy… It’s just that there are a few points where if you deviate slightly based on your device, EVERYTHING stops working. With that said:

This guide is for ASUS Google Nexus 7 Tablet (7-Inch, 16 GB, Black) 2013 Model only (Android 5.1.1 build LMY48G). It can be adapted to work with other models, I’m sure, but I plan to explicitly call out where my missteps where so that anyone with the exact same hardware as me can have a smoother ride. I also take ABSOLUTELY NO RESPONSIBILITY if you brick your device.


  1. Make a folder somewhere on your computer (like your desktop) that you are going to put all of your downloads into.
  2. Make sure you have ADB and FastBoot on your path, OR you put all of the necessary files to run ADB and FastBoot from a command prompt into the folder you made in step 1.
  3. You’re going to need to unlock your bootloader if you haven’t already. Unlocking your bootloader WILL erase your device. Follow the steps outlined here. In short, these steps are:
    1. Enable USB debugging on the device
    2. Open a command prompt in your folder from step 1
    3. Type: adb reboot bootloader
    4. Press enter to execute the command
    5. Wait for the device to boot into the bootloader…
    6. Type: fastboot oem unlock
    7. Press enter to execute the command
    8. Use the volume buttons on the device to change selection to Yes
    9. Use the power button on the device to select Yes
    10. Unlocked!
  4. You’re going to need to flash a new stock ROM to your device. Timur doesn’t call out LMY48G as supported in his instructions, but LMY48T is!) so go to Factory Images for Nexus Devices and download the image for 5.1.1 (LMY48T).
  5. Extract the contents of the LMY48T tar.gz file into your folder from step 1.
  6. Run the flash-all.bat file that was extracted from the LMY48T download. When this completes successfully, you will have a phone in a brand new state…
    1. Follow all the instructions on the device to get set up again with your new factory ROM
    2. Go to “About tablet” in settings and check that build number is now LMY48T… If it’s not, then DO NOT CONTINUE. You’ll need to get LMY48T before continuing with these steps.
    3. Follow all the steps again to get USB debugging available again
  7. You’re going to need to flash a recovery onto your device next. I used TWRP for this. HOWEVER, not just any TWRP worked for me. I needed to use the “multirom” version of TWRP (specifically, I used TWRP_multirom_flo_20150328).
    1. Download the TWRP multirom image to your folder created in step 1
    2. Put your phone into bootloader mode by typing: adb reboot bootloader
    3. Press enter to execute the command
    4. Wait for your phone to enter bootloader mode
    5. Type: fastboot flash recovery TWRP_multirom_flo_20150328.img
    6. NOTE: if you did not download the EXACT same TWRP as me, then change it to the correct file name…
    7. Press enter to execute the command. The device should inform you that flashing worked.
    8. Use the volume buttons on the device to change selection to booting to recovery
    9. Use the power button to select boot to recovery
    10. … You should see the TWRP splash as you boot to recovery
    11. Wait for this to load
  8. You’re almost there!
  9. We need to grab the timur files now. I was a little thrown off when navigating the FTP, but you only need TWO files: the host and the services files.
    1. Download timur-services-N7-2-511e-v3-2015-10-06.zip (or whatever the latest version of services is with 511-e is) into your folder created in step 1
    2. Download timur-usbhost-flo511-v3.0-2015-10-20.zip (or whatever the latest version of usbhost is with flo511 is) into your folder created in step 1
    3. We need to push these two files to the device’s internal SDCARD, so…
    4. NOTE: please use the correct file names in the following commands if yours are different…
    5. Type: adb push timur-services-N7-2-511e-v3-2015-10-06.zip /sdcard/
    6. Press enter to push the file… ADB should tell you if it worked.
    7. Type: adb push timur-usbhost-flo511-v3.0-2015-10-20.zip /sdcard/
    8. Press enter to push the file… ADB should tell you if it worked.
  10. On the device, press the big “install” button on the main part of the TWRP recovery
  11. Add both zips that you pushed to the device (remember, they are in the /SDCARD/ folder and you’ll need to make sure TWRP is filtering by zips)
  12. Flash ’em…
  13. Use TWRP to reboot… mine prompted me to install supersu. I opted for YES.
  14. As the phone is booting up, it may say some stuff about optimizing apps… If it does this for forever and then reboots and keeps doing this again for forever, it’s very likely that you mismatched the timur files… I encountered this problem twice and had to reflash the correct stock ROM again… so head back to step 1 🙂
  15. Once the phone boots up, go to about tablet under settings and check your kernel… It should say timur in there!
  16. If you saw timur in step 15… You’ve done it!

NOTE: If anyone goes through this guide and wants to suggest clarifications, please comment and I’ll try to update it.


  • I had to use the correct version of TWRP (the multiboot one) to get anywhere with this. I tried latest releases of CWM and TWRP but neither could seem to mount my system partition when doing the zip installs. This was incredibly frustrating and probably chewed up around two to three hours of my time debugging. I tried rooting etc… Nothing would fix it. The ONLY thing that seemed to work was TWRP multiboot.
  • My first pass through getting timur kernel installed resulted in a bootloop, which was super frustrating. Timur called out specific builds of Android that his kernel works for, and even though LMY48G wasn’t listed, I guess at which files to use and it failed miserably. Lesson learned. This is why i suggested flashing one of the supported stock Android images RIGHT at the beginning. If you don’t get everything lined up (and he’s explicit about this… I was just being dumb) then you will very likely encounter problems and need to redo everything.

Hack Your TODO List With Google Keep

Hack Your TODO List With Google Keep

Trying To Keep It Alllll Together…

I’m a big fan of TODO lists. I find that they’re a great way for me to set up a bunch of tasks and feel really productive as I work through them. I’ll make TODO lists for almost anything. What do I need to get done tomorrow morning at work? What groceries do I need to get? What topics am I thinking of blogging about? I’ll get some sort of TODO list going for anything.

The one thing that I need in my TODO list to stay effective is to constantly have it around me to remind me. I was running the Evernote app on my Android phone and recently made the observation that things that I put in there had a much higher likelihood of getting done versus things I put in my work notebook. The reason? I check my phone a lot more than my work notebook. I have my phone with me when I grocery shop. I have it before and after I workout at the gym. It’s my alarm in the morning so I have access to it as soon as I wake up. My work notebook? Not so much.

The problem here is that my important work tasks I want to accomplish were not getting the same treatment my out-of-work tasks were getting. They weren’t getting the same success rate.

Enter Google Keep

I try to meet up with my teammates once a month to discuss their goals or things we need to work through at the office. In my last round of one-on-ones, I was discussing my TODO lists with one of my colleagues, Samantha. She said that she noticed I was using Evernote, but was curious of I’ve ever tried out Google Keep. I admitted that I hadn’t, but she was speaking highly of it. “Why not give it a shot?” I thought. But it hacked my TODO list concept in a big way.

Google Keep has one feature that I think is totally awesome on my phone. I never tried this with Evernote, so I’m not claiming that it can’t do this. The phone widget is truly awesome. Right on my homescreen of my phone, I can see my TODO lists. This takes that first point I was discussing (need to have access to it all the time) to a whole new level. Now instead of having to go to the app itself to get refreshed on what I need to do, almost any time I touch my phone I’m having visibility into my TODO lists.

A second powerful feature is the idea of checkboxes for progress. This probably sounds like it’s not all that important. “Google Keep has checkboxes? Great… I have bullet points in any other app I can get my hands on!” I can hear you saying that now 😉 But it’s different. I was using Evernote and keeping bulleted lists, and when I was through with something, I’d just delete the whole bullet point. The idea of checking things off your list is powerful because it shows you that your making progress. I can see that I have only 3 of 10 items left on my list and that gives me a bit more drive to try and knock off the rest. If my list is always just a view of what’s left, it will always feel like it’s never done.


I’m not trying to push Google Keep or bash Evernote here… I’m just trying to show you how a few simple hacks in my TODO lists were able to provide some real positive benefits. For me, the things I need in my TODO list technology are:

  • Easy to access
  • Ability to access frequently
  • Insight into progress I’m making on the list
  • … Not cost me a cent!

Your list might look a bit different. You could argue that you don’t always want the list in front of you or that you don’t want total transparency into the progress you’re making. I can’t speak for you in terms of what will be most effective, but I highly recommend Google Keep after using it for only a couple of weeks.

Now my only problem is that I look like I’m ignoring people if I’m taking notes on my phone in a meeting! Thanks for the suggestion, Sam!

Article Summaries: Weekly Article Dump #17

Article Summaries: Weekly Article Dump #17 (Image from http://www.sxc.hu/)


  • It’s official: Video games make your brain bigger: I don’t have much time for video games anymore, but this is still totally awesome news. It’s in. It’s official. Video games can actually make you smarter. How great is that? If you’re like me and you find you don’t have much time for games any more, it might be worth picking up a hobby game. It’s a great way to relax provided you don’t get too addicted to it and apparently it can make you smarter. Perfect combo!
  • The myth of the brainstorming session: The best ideas don’t always come from meetings: I thought this article was pretty interesting because we do a lot of brain storming at our office. Sometimes I like to think the sessions go smoothly or that they’re productive. When I contrast them with particular cases that are a bit out of our ordinary approach, it seems like there are certainly some factors that improve the outcome.
    We’ve been dabbling in some personality tests to understand team dynamics a little bit better. To the article’s point, extroverted personalities almost always overrun introverted personalities in a brainstorming meeting from my experience. It’s really unfortunate actually and clearly not really fair if everyone is supposed to be getting their ideas out. In order to get the best results, I think that everyone needs a way to get their thoughts out, and sometimes it’s not doable if you have certain people overrunning others.
    The article also touches on a fear of judgement concept that I think certainly holds true. In a recent brainstorming style meeting, instead of having individuals put on the spot and discuss their opinions, we white boarded them all at once. There was anonymity aside from when the person right beside you writing could peek at what you were putting down. The results were much better than any of our previous meetings of this style. I can’t be entirely sure that the whiteboarding was the reasoning, but it’s definitely something I’d like to try again in the future.
  • Matt Chang – Team Magnet Recognition: This is a post I put out earlier this week. As part of my attempt to recognize the amazing team of people I work with at Magnet Forensics, I decided to write up about our superstar customer/tech support. I know I’d never survive in a tech support role, so I have even more respect for Matt Chang being able to do such a good job. He’s been a great addition to the team, and he makes our troubleshooting of customer issues infinitely easier. Thanks for all your amazing work, Matt.
  • 6 Talent Management Lessons From the Silicon Valley: In this article by John Sullivan, he discusses talent management in the valley. The fundamental idea here is that it’s all driven by innovation. Some key take away points from the article is that innovation is actually a more important goal than productivity and the ability to move fast has a huge affect on this. Additionally, people who innovate want to have an impact. Sharing stories about how previous feats have proven to have a great impact can also be a great driving force.
  • Quality & Agility in Software: Session With Paul Carvalho: This is another article I put out this week about Paul Carvalho who came to speak to our development team. Simply put, the time we had with Paul was packed with information and activities. Every second we spent with him felt like we were absorbing something new and useful. It was far too short. We had lots of great learnings to take away and bring to our own drawing board. We’re excited to be implementing some changes in the upcoming week.
  • Rather than Whine, We Can Learn from the Boring Aspects of a Job: Mohamed El-Erian reminds us that even the most interesting and glamorous jobs have dull moments. We shouldn’t whine or avoid these situations–they’re vital stepping stones. It’s not realistic to assume you can cut every corner and take every shortcut to get exactly where you want in your career and in life. You have to work hard at what you do and embrace even the small things that can seem boring and monotonous.
  • Fragments: Creating a Tabbed Android User Interface: This is yet another one of my posts that I shared this week. This is my first Android tutorial, and I’m pretty proud of it! It’s very basic, has lots of pictures, and all of the sample code is available to download. I’m confident that anyone interested in picking up Android programming would be able to follow along. Even experienced programmers looking for a way to get a tabbed user interface using fragments in their Android app should find some benefit too! I just found out today that my tutorial made it into the Android Weekly Issue #76, so that was pretty exciting. You can download the app too (it’s pretty basic) to see what the end result will be. Check it out and let me know what you think.

Remember to follow Dev Leader on social media outlets to get these updates through the week.

Nick Cosentino – LinkedIn
Nick Cosentino – Twitter
Dev Leader – Facebook
Dev Leader – Google+
Nick’s CodeProject Articles

Fragments: Creating a Tabbed Android User Interface

Fragments: Creating a Tabbed Android User Interface

Fragments: A Little Background

Update: The actual application is available on the Google Play store.

Once upon a time, Android developers used only two things called activities and views in order to create their user interfaces. If you’re like me and you come from a desktop programming environment, an Activity is sort of like a form or a window. Except it’s more like a controller for one of these classes. With that analogy in place, a view is then similar to a control. It’s the visual part you’re interacting with as a user. I remember the learning curve being pretty steep for me being so stuck in my desktop (C# and WPF) development, but once I came up with these analogies on my own, it seemed pretty obvious. So to make an Android application, one would simply put some views together and chain some activities to show these views. Pretty simple.

Something changed along the way though. It was apparent that the Activity/View paradigm was a bit lacking so something new was added to the mix: The Fragment. Fragments were introduced in Android 3.0 (which is API level 11). Fragments added the flexibility to be able to swap out parts of an activity without having to completely redefine the whole view. This means that having an application on a mobile phone with a small screen can appear differently than when it’s on a large tablet, and as a developer you don’t have to redesign the whole bloody thing. Awesome stuff!

So, to clarify, a fragment is just a part of the activity. By breaking up activities into fragments, you get the modular flexibility of being able to swap in and out components at will. If you’re like me and you took a break from Android when fragments were introduced, then you may have another little learning curve. The goal of this article is to create a tabbed Android user interface using fragments.

For what it’s worth, when I first tried putting together a tabbed UI with fragments, it was a complete mess. I was surfing the net for examples, but I couldn’t find anything that really hit it home for me. Once I had it working, I decided I should redo it and document the process. That’s how this article came to be! Another side note… I’m a C# developer by trade and I haven’t developed with Android/Java within a team. If you don’t like my coding conventions then please try to look past that to get the meat of the article!

As per usual, you can follow along by downloading all of the code ahead of time. Please check out the section at the end of the article and pick whichever option you’d like to get the source!

Setting Up: Getting Your Project Together

I’m going to make a few assumptions here. You should have Eclipse installed with the latest Android Development Tools. There are plenty of examples out there for how to get your environment put together, but I’m not going to cover that here.

You’re going to want to start by making a new Android Application in eclipse. By going to the “File” menu, then the “New” sub menu, then the “Other” sub menu, you should get a dialog letting you pick Android application. You’ll get a wizard that looks like the following (where I’ve filled in the information with what I’ll be using for this entire example):

Tab Fragment Tutorial - New Android Application

The first part of the wizard is setting up your Android project.

The wizard gives you some options for what you want to have it generate for you. In this case, I opted out of having a custom icon (since that’s not really important for this tutorial) and I chose to have it create an activity for me.

Tab Fragment Tutorial - Create Activity

The second step in the wizard lets you choose what to create. I wanted just the activity made.

Our activity is actually going to be pretty light-weight. The bulk of what we’re going to be doing is going to be inside of our fragments. Because of this, we should be totally fine just making our main activity a simple blank activity.

Tab Fragment Tutorial - Create Blank Activity

We won’t have much code in our main activity. Let’s just opt for the blank activity.

The final step in the wizard just wants you to confirm the naming for your generated code.

Tab Fragment Tutorial - Activity Naming

Let’s create our “MainActivity” activity with a layout called “activity_main”. Pretty straight forward.

At this point, we actually have an Android application that we can deploy to a phone or a virtual device. If you’re new to Android programming, I suggest you try it out. It’s pretty exciting to get your first little application running.

The Layouts

The layout XML files in Android provide the hierarchies of views that will get shown in the UI. If you haven’t modified the one that was created by default, it will probably look like this:

Tab Fragment Tutorial - Initial Main Activity Layout XML

The default Main Activity XML will look like this. It’s really just a text view that says “Hello World”.

What does that give us? Well, we get a RelativeLayout view that acts as a container for a TextView. The TextView says “Hello World”. Amazing, right?

Let’s switch up our main activity’s layout a bit. Instead of a RelativeLayout, let’s drop in a linear layout that has a vertical orientation. We’ll blow away the TextView too, and drop in a Fragment. Our fragment will need to point to our custom fragment class (which we haven’t created yet). For now, make the class “com.devleader.tab_fragment_tutorial.TabsFragment”. Later in the example, we’ll create the TabsFragment class and put it within this package. When the application runs, it will load up our custom fragment (specified by the full class name) and place it within our LinearLayout.

The layout XML for the main activity looks like the following:



android:layout_height="fill_parent" />


We’re going to need a layout for our tabs fragment. This is going to be the view portion of the UI that gets dropped in to our main activity. It’s going to be responsible for showing the tabs at the top of the UI and then providing container views for the contents that each tab will want to show.

In order to create this layout, right click on your “layout” folder nested within the “res” folder in the Eclipse IDE. Go to “new”, and then click on the “Other” child menu. Pick “Android XML Layout File” from your list of options. Select “TabHost” as the layout’s root element. Let’s call this file “fragment_tabs.xml”.

The top level component in this layout will be a TabHost. We’ll put our TabWidget in next, which is going to contain the actual tab views, and then a FrameLayout with two nested FrameLayouts inside of it for holding the contents that we want to show for each tab. To clarify, the user will be clicking on views within the TabWidget to pick the tab, and the contents within the tab1 and tab2 FrameLayouts will show the corresponding user interface for each tab.

The layout XML for the tabs fragment looks like the following:




android:layout_height="wrap_content" />


android:background="#FFFF00" />

android:background="#FF00FF" />



You may have noticed I used some pretty aggressive hard-coded colors in the layout file. I highly advise you switch these to be whatever you want for your application, but when I’m debugging UI layouts I like to use really high contrasting colors. This helps me know exactly where things are (as opposed to having 10 views all with the same background). Maybe I’m a bit crazy, but I find it really helpful.

Now that we have the main activity done and the tab fragment all set up, the last thing we need is to create some sort of layout for our individual tab views. This will be the view that is placed inside of the TabWidget on our tabs fragment layout. These views will have the title of the tab and they’ll be what the user actually interacts with in order to switch tabs.

The layout XML for our simple tab view looks like the following:


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" >

android:textAppearance="?android:attr/textAppearanceLarge" />



And that’s it for layouts! Just these three simple files. Now, we need to fill out our classes!

The Classes

If we start from the beginning with the classes, the first (and only) class that gets generated for you is the MainActivity class. If you left it untouched (hopefully you did since there was no indication to change it yet!) then you should have a class that looks like:

Tab Fragment Tutorial - Initial Main Activity Class

The default MainActivity class that gets generated after we complete the steps in the wizard.

In order to make this example work, we barely even need to modify this class at all. You’ll notice our MainActivity extends the Activity class. Because we’re going to be using fragments in our application, we need to modify this class to extend the FragmentActivity. In this entire example, I opted to use the Android v4 Support Library. Thus, in order to make this example work, please ensure you’re using FragmentActivity from the package “android.support.v4.app.FragmentActivity“.

Once you’ve made this replacement (“Activity” for “FragmentActivity”) we’re all done in this class. Great stuff, right? Let’s move on.

We’re going to want to make a class that defines what a tab is. In order to make some nice re-usable code that you can extend, I decided to make a base class that defines minimum tab functionality (at least in my opinion). Feel free to extend upon this class later should your needs exceed what I’m offering in this tutorial.

The base TabDefinition class will:

  • Take in the ID of the view where the tab’s content will be put. In our example, this will be the ID for tab1 or tab2’s FrameLayout.
  • Provide a unique identifier to look up the tab.
  • Be required to provide the Fragment instance that will be used when the tab is activated.
  • Be required to create the tab view that the user will interact with in order to activate the tab.

Let’s add a new class called “TabDefinition” to the package “com.devleader.tab_fragment_tutorial”, just like where our MainActivity class is. The code for the TabDefinition class is as follows:


package com.devleader.tab_fragment_tutorial;

import java.util.UUID;

import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

* A class that defines a UI tab.
public abstract class TabDefinition {
// Fields
private final int _tabContentViewId;
private final String _tabUuid;

// Constructors
* The constructor for {@link TabDefinition}.
* @param tabContentViewId The layout ID of the contents to use when the tab is active.
public TabDefinition(int tabContentViewId) {
_tabContentViewId = tabContentViewId;
_tabUuid = UUID.randomUUID().toString();

// Exposed Members
* Gets the ID of the tab’s content {@link View}.
* @return The ID of the tab’s content {@link View}.
public int getTabContentViewId() {
return _tabContentViewId;

* Gets the unique identifier for the tab.
* @return The unique identifier for the tab.
public String getId() {
return _tabUuid;

* Gets the {@link Fragment} to use for the tab.
* @return The {@link Fragment} to use for the tab.
public abstract Fragment getFragment();

* Called when creating the {@link View} for the tab control.
* @param inflater The {@link LayoutInflater} used to create {@link View}s.
* @param tabsView The {@link View} that holds the tab {@link View}s.
* @return The tab {@link View} that will be placed into the tabs {@link ViewGroup}.
public abstract View createTabView(LayoutInflater inflater, ViewGroup tabsView);


Now that we have the bare-minimum definition of what a tab in our UI looks like, let’s make it even easier to work with. In my example, I just want to have my tabs have a TextView to display a title–They’re really simple. I figured I’d make a child class of TabDefinition called SimpleTabDefinition. The goal of SimpleTabDefinition is really just to provide a class that takes the minimum amount of information to get a title put onto a custom view.

Please keep in mind that there are many ways to accomplish what I’m trying to illustrate here, but I personally felt having a base class with a more specific child class would help illustrate my point. You could even put in a second type of child class that would make a graphical tab that shows a graphical resource instead of a string resource. Tons of options!

Let’s add another new class called “SimpleTabDefinition” to the package “com.devleader.tab_fragment_tutorial”. The code for SimpleTabDefinition is as follows:


package com.devleader.tab_fragment_tutorial;

import android.support.v4.app.Fragment;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.LinearLayout.LayoutParams;

* A class that defines a simple tab.
public class SimpleTabDefinition extends TabDefinition {
// Fields
private final int _tabTitleResourceId;
private final int _tabTitleViewId;
private final int _tabLayoutId;
private final Fragment _fragment;

// Constructors
* The constructor for {@link SimpleTabDefinition}.
* @param tabContentViewId The layout ID of the contents to use when the tab is active.
* @param tabLayoutId The ID of the layout to use when inflating the tab {@link View}.
* @param tabTitleResourceId The string resource ID for the title of the tab.
* @param tabTitleViewId The layout ID for the title of the tab.
* @param fragment The {@link Fragment} used when the tab is active.
public SimpleTabDefinition(int tabContentViewId, int tabLayoutId, int tabTitleResourceId, int tabTitleViewId, Fragment fragment) {

_tabLayoutId = tabLayoutId;
_tabTitleResourceId = tabTitleResourceId;
_tabTitleViewId = tabTitleViewId;
_fragment = fragment;

// Exposed Members
public Fragment getFragment() {
return _fragment;

public View createTabView(LayoutInflater inflater, ViewGroup tabsView) {
// we need to inflate the view based on the layout id specified when
// this instance was created.
View indicator = inflater.inflate(

// set up the title of the tab. this will populate the text with the
// string defined by the resource passed in when this instance was
// created. the text will also be centered within the title control.
TextView titleView = (TextView)indicator.findViewById(_tabTitleViewId);

// ensure the control we’re inflating is layed out properly. this will
// cause our tab titles to be placed evenly weighted across the top.
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
layoutParams.weight = 1;

return indicator;


Awesome stuff. Now we can define tabs easily in our application. We just have one more class left, I promise! In the following section, I’ll re-iterate over everything, so if you’re feeling a bit lost… Just hang in there.

The one part we’re actually missing is the fragment that will manage all of our tabs. We created the layout for it already, which has a TabHost, a TabWidget (to contain the clickable tab views), and some FrameLayouts (that contain the content we show when we press a tab). Now we just need to actually attach some code to it!

The TabsFragment class that we’re going to want to add to the package “com.devleader.tab_fragment_tutorial” is responsible for a few things. First, we’re going to be defining our tabs in here. This class will be responsible for taking those tab definitions and creating tabs that get activated via the TabHost. As a result, this fragment class is going to have to implement the OnTabChangedListener interface. This will add a method where we handle switching the fragment shown to match the fragment for the contents of the tab that was pressed.

The code for our TabsFragment class looks like the following:

package com.devleader.tab_fragment_tutorial;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TabHost;
import android.widget.TabHost.OnTabChangeListener;
import android.widget.TabHost.TabSpec;

* A {@link Fragment} used to switch between tabs.
public class TabsFragment extends Fragment implements OnTabChangeListener {
// Constants
private final TabDefinition[] TAB_DEFINITIONS = new TabDefinition[] {
new SimpleTabDefinition(R.id.tab1, R.layout.simple_tab, R.string.tab_title_1, R.id.tabTitle, new Fragment()),
new SimpleTabDefinition(R.id.tab2, R.layout.simple_tab, R.string.tab_title_2, R.id.tabTitle, new Fragment()),

// Fields
private View _viewRoot;
private TabHost _tabHost;

// Exposed Members
public void onTabChanged(String tabId) {
for (TabDefinition tab : TAB_DEFINITIONS) {
if (tabId != tab.getId()) {

updateTab(tabId, tab.getFragment(), tab.getTabContentViewId());

throw new IllegalArgumentException("The specified tab id ‘" + tabId + "’ does not exist.");

public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
_viewRoot = inflater.inflate(R.layout.fragment_tabs, null);

_tabHost = (TabHost)_viewRoot.findViewById(android.R.id.tabhost);

for (TabDefinition tab : TAB_DEFINITIONS) {
_tabHost.addTab(createTab(inflater, _tabHost, _viewRoot, tab));

return _viewRoot;

public void onActivityCreated(Bundle savedInstanceState) {


if (TAB_DEFINITIONS.length > 0) {

// Internal Members
* Creates a {@link TabSpec} based on the specified parameters.
* @param inflater The {@link LayoutInflater} responsible for creating {@link View}s.
* @param tabHost The {@link TabHost} used to create new {@link TabSpec}s.
* @param root The root {@link View} for the {@link Fragment}.
* @param tabDefinition The {@link TabDefinition} that defines what the tab will look and act like.
* @return A new {@link TabSpec} instance.
private TabSpec createTab(LayoutInflater inflater, TabHost tabHost, View root, TabDefinition tabDefinition) {
ViewGroup tabsView = (ViewGroup)root.findViewById(android.R.id.tabs);
View tabView = tabDefinition.createTabView(inflater, tabsView);

TabSpec tabSpec = tabHost.newTabSpec(tabDefinition.getId());
return tabSpec;

* Called when switching between tabs.
* @param tabId The unique identifier for the tab.
* @param fragment The {@link Fragment} to swap in for the tab.
* @param containerId The layout ID for the {@link View} that houses the tab’s content.
private void updateTab(String tabId, Fragment fragment, int containerId) {
final FragmentManager manager = getFragmentManager();
if (manager.findFragmentByTag(tabId) == null) {
.replace(containerId, fragment, tabId)


And that’s it! Just four classes in total, and one of them (MainActivity) was almost a freebee!

Putting It All Together

Let’s recap on all of the various pieces that we’ve seen in this example. First, we started with the various layouts that we’d need. Our one and only activity is pretty bare bones. It’s going to contain our tabs fragment view. The tabs fragment view is responsible for containing the individual tabs a user clicks on as well as the content that gets displayed for each tab. We also added a layout for really simplistic tab views that only really contain a TextView that shows the tab’s title.

From there, we were able to look at the classes that would back up the views. To use our fragment implementation, we only had to modify our parent class of our only activity. I opted to create some classes that define tab functionality to make extending the UI a bit easier, and adding additional child classes that fit in this pattern is simple. The TabsFragment class was the most complicated part of our implementation, and truth be told, that’s where most of the logic resides. This class was responsible for defining the tabs we wanted to show, and what fragments we would swap in when each tab was clicked.

In order to extend this even more, the things you’ll want to consider are:

  • Defining your own type of tab definition classes. Maybe you want to look at graphical tabs, or something more complicated than just a title.
  • Implementing your own fragment classes that you display when your tabs are clicked. In the example, the contents of the tabs are empty! This is definitely something you’ll want to extend upon.
  • Adding more tabs! Maybe you need three or four tabs instead of two.


Fragments in Android really aren’t all that complicated. As a new Android developer or transitioning from the pre-API level 11 days, they might seem a bit odd. Hopefully after you try out this example they’re a lot more clear. Hopefully by following along with this tutorial you found that you were easily able to set up a tabbed user interface in Android and get a basic understanding for how fragments work.

Source and Downloads

I like being able to provide the source in as many formats as possible… so here we go:

Update: The actual application is available on the Google Play store.

  • Copyright © 1996-2010 Dev Leader. All rights reserved.
    Jarrah theme by Templates Next | Powered by WordPress