• 5,596,919
  • 48,945

Posts Tagged: library


Recently, we featured a guide by XDA Senior Member Dr.Alexander_Breen aimed at bringing lockscreen-like music controls to your app. However, the method was overly complicated for many users. So in order to make the process easier, Dr.Alexander_Breen has created the open source library Remote Metadata Provider. And since it’s licensed with Apache 2.0, you can use in your projects (commercial or not).

Remote Metadata Provider allows you to create your own remote media controls, which behave similarly to the lock screen music controls described in the developer’s previous guide. However, usage of the Remote Metadata Provider library is much simpler than the last. You first add the library to your development project as an external JAR. Then, you follow a clear guide with example code listed within the thread’s main post.

Currently, there is a bug on HTC Sense devices, where you lose lock screen controls after calling RemoteMetadataProvider#acquireRemoteControls(). There is also (temporarily) a bug when using Android 4.3. However, this will be fixed in a future version.

Head over to the library and tutorial thread to get started.


One week ago, we featured a guide by XDA Senior Member marty331 posted in our App Development forums aimed at helping application developers create in-app usage tutorials using transparent demo overlays atop application activities. However, not everybody is a designer able to create aesthetically appealing overlays. Luckily, XDA Senior Member nikwen discovered the open source ShowcaseView library by Alex Curran, which makes it easy to generate Holo-themed demo overlays with ease.

In addition to describing the Apache 2-licensed library, nikwen also put together a quick guide that teaches developers how to showcase views, views in fragments, and parts of the action bar. He also describes how to add listeners to the library to trigger the event, as well as add animations such as a virtual finger that performs a gesture.

As we stated before, one of the keys to getting users comfortable and happy with your application is to show them how to use it. Head over to the guide thread to get started.


In our continuing coverage of the App Development forums here at XDA, we’ve featured various open source libraries that  enable you to quickly add in functionality into your app-in-progress without having to reinvent the wheel. These libraries have streamlined app development in topics ranging from UI design and data visualization  to application updates and everything in between.

Now, thanks to XDA Senior Member klinkdawg, there is an open source library for SMS and MMS messaging. After gaining knowledge while creating his own messaging app, klinkdawg released his library with the intention of helping other developers create their own SMS and MMS apps.

In addition to simply sharing the code, the developer has also written a brief guide in the thread that should cover basic usage. Currently, Google Voice is not supported, but that is on the way in a future revision. Additionally, this library is in beta, and uses non-final APIs.

Despite the beta status, this library could be of use if you’ve been planning on adding text messaging to your app. Head over to the library thread and knlinkdawg’s Github to get started.


Are you a developer using Mono for Android to develop pseudo-cross platform code using C# or .Net? If so, you may wish to save a few keystrokes for commonly executed commands.

XDA Senior Member ScatteredHell has created a DLL that works with Mono for Android to execute various commands. Originally, it supported obtaining system uptime, as well as some commonly used root-level commands such as mounting and unmounting the system as Read/Write and Read-Only, Rebooting, Setting Permissions, and Playing a Boot Animation. Now in its second version, it adds Get Date, Get Time, and Get Folders in a Specified Path to the list of supported commands. Example code is also given in the thread, demonstrating its usage.

While these shortcuts won’t save you massive amounts of time, the shortcuts will add up over time. Head over to the original thread to get started and streamline your Mono usage.


If you’re creating an application that displays a list, you will likely want to use a ListView. Now if you wish to make it look nice with animations and additional features such as different view types and expandable items, you would ordinarily have to do the hard work and add in the functionality yourself.

Thankfully, XDA Forum Member Niekfct shared his latest library for application developers in our relatively new App Development forums. So what functionality is available with this library? Currently, it offers list- and grid-view animations, and it also supports swipe to dismiss, expandable data points, and more. And to ensure compatibility with older devices, the library uses the NineOldAndroid library on devices running versions of Android older than Honeycomb.

If you wanted to easily add a ListView in your app and want it to have some snazzy animations, head over to the library thread to get started. Naturally, the library is open source, with the code available at the developer’s Github. Example code is available on the developer’s project page.


Over the years, the process for connecting Android devices to proxy servers has changed dramatically. Originally only supporting global configuration, now configurations can be set on a per access point basis. Furthermore, applications such as OpenVPN can work globally on devices running Ice Cream Sandwich and later.

So what do you do if you’re building an application and you want your to know a user’s proxy configuration? Up until now, this would be a pretty difficult task. Luckily, XDA Forum Member lechuckcaptain has already gone through the hassle so that you don’t have to. He has created a library to do this for you, regardless of the user’s Android version supporting from 1.x through 4.x. The library began with determining current proxy configuration, but has now grown to also ascertaining proxy status and other relevant information.

Head over to the library thread and visit lechuckcaptain’s Github to get started.


Think back to all those times when your non-tech savvy parents have called you over for free computer tech support. What’s one unifying theme from all of these instances? If your loved ones are anything like mine, it’s a horde of uninstalled updates awaiting approval. This is unfortunately all too common, as most of the technologically illiterate simply ignore update notifications, without realizing that these updates often patch vulnerabilities and add important features.

Luckily on Android, updates can be set to automatically install if the app’s permissions haven’t changed. However, not everyone has auto-update enabled, and even those with the option enabled may not take the time to manually update applications with changed permissions in the app manifest. In these instances, users need a little bit of prodding to get them to be a man and do the right thing—update their applications.

As a developer, not having users on the latest version of your app can be problematic. After all, who wants users complaining about broken features that have already been fixed two versions ago? Thankfully, XDA Senior Member rampo created a library to help with this problem in your own app. So how does the library work? Simple. UpdateChecker is a class that when called checks to see if the app is updated to the latest version available in the Play Store by parsing your app’s desktop Play Store listing. If there is a newer version available, the user is then prompted to update.

Head over to the library thread to prod your users to update.


We’ve featured plenty of tools in the past that allow an end-user to modify his or her own build.prop. We’ve also featured a set of tools for app developers to incorporate that allow applications to modify the file. These (obviously) all require root access, as you’re modifying system settings. However, to date we haven’t featured a method of reading the build.prop from an app.

There are plenty of reasons why an app developer would want read-only access a device’s build.prop. Be it to know about its software or hardware configuration, or simply to peek into some system settings, looking into this treasure trove of information is potentially quite useful for an app developer. However, requiring root access to do so is unnecessary from both user hassle and security standpoints.

In a quest to access the build.prop from his own app without resorting to root, XDA Forum Member torpedo mohammadi wrote a couple of lines of code and shared it with the community. The way he goes about it can be summarized in his explanation:

1. Make a process which executes “getprop” from the “/system/bin/getprop” directory and initialize the String which we want to get (ro.board.platform in example).
2. Make a BufferedReader which gets the value (String) by retrieving the data from a inputStreamReader().
3.Convert the BufferedReader to String.

Head over to the original thread to get started, copy the code, and get it implemented into your app.


It’s no secret that visual aids such as charts and graphs help in effectively disseminating numerical information. After all, who really wants to read an essay of numbers? That feeling is only exacerbated when the reading is done on a small cell phone screen. Thankfully, as apps are becoming more and more visually enriched, dull data visualization is nearly a thing of the past.

To help developers better display exactly the data they need in their apps, XDA Senior Member Androguide.fr created HoloGraphLibrary. Forked from a separate base library by developer Daniel Nadeau, Androguide.fr’s offering builds on the original by adding support for various unit display types and compatibility with Android Studio and Gradle.

In addition to providing his forked library, Androguide.fr has also included a comprehensive guide on how to use the library in his thread. So what are you waiting for? Don’t display numbers as text; it’s not pretty. Head over to the library thread to get started.


If you’re looking to get started creating a user interface for your app, there are various ways of getting started. You could always start from scratch, learning the entire process as you go along. In fact, that’s probably the ideal way of doing it, provided you have the time, as you’d have a deeper understanding of how things work and how to fix problems if when they arise.

However, ain’t nobody got time to do things the long way. To help speed things along for new developers who would rather concentrate on core functionality code rather than UI layouts, XDA Senior Member AuxLV created GrilledUI, an open source streamlined library aimed at easily creating common UI layouts. As described by AuxLV:

Available UI types are: tabbed UI (TabActivity), master/metail flow (SectionActivity) and their hybrid (HybridActivity). These activity classes wrap everything you need to create your UI with just a few lines of code or even load tabs/sections and instaniate fragments from XML file. HybridActivity allows you to have tabs on phones and MDF on tablets. This way you can easily make your app tablet and phone friendly without torturing phone users with multiple activities.

Included with the library are multiple examples, a BSD license, and support for pre-ICS devices using ActionBarSherlock. Head over to the resource thread to get started and visit the Github to take a peek at the source.


Let’s imagine that you’re putting the finishing touches on your application, when you suddenly realize one thing: You wish to add in the ability to modify a device’s build.prop directly from the app.

Yes, this is far from applicable to every app developer. However, quite a few classes of apps could make use of the ability to modify a device’s build.prop such as tools that allow users to change what device an end user’s phone identifies as, or an app that just gives users the ability to modify the build.prop directly themselves.

Now, if you’re currently developing your application and would like to bake in the ability to modify the build.prop file, you could obviously figure out how to do it yourself. Alternatively, you could check out an open source library created by XDA Senior Member Tezlastorme geared at helping you add exactly that functionality into your own app.

Created out of necessity when Tezlastorme needed but couldn’t find such a library himself, he decided to spare future developers from having to reinvent the wheel in their projects. In his own words:

Over the past few days I have been working on making a library that makes it easier for app developers to edit the build.prop file from their applications. I decided to make this library when I needed to edit build.prop from within an app I’m developing and I couldn’t find a library to make this simple. So, after I had worked out how to do it and tested the code in my app, I made it into a library, because I think this will help quite a few developers.

Those looking to add in build.prop modification to their should head over to the original thread to get started.


Geolocation games are just inherently cool. Don’t believe me? Just think how much of the magic of Ingress would be lost if it weren’t based on your position.

If you’re a mobile games developer, you more than likely have already considered creating your own geolocation-based game. Thankfully, if you decide to force others to get off their lazy behinds by creating such a game, XDA Forum Member Robyer has a library that you can use that will help get you started without much hassle.

Originally created as part of his Bachelor’s degree thesis, the Gamework library is currently aimed at creating single-player games without moving enemies (i.e. without enemies or AI). Thus, you’re best left using it for puzzle or strategy games. However, Robyer is eager to hear suggestions to expand the library to support additional features that developers may desire.

Want to know the best part? The library is fully open source, licensed under Apache v2, meaning that you can use it however you’d like—even for commercial applications. So if you have any ideas and want to either contribute to the development of the library or create your own game, you should head over to the original thread.


Everyone who builds ROMs knows about the repo tool, right? I say wrong. You can build ROMs all the live long day and know nothing about it. But you’ll face-palm after learning about what you’re missing.

The repo tool is a Python script that adds a layer of abstraction between you and Git. Git is of course the source code management system used by the Android code base. If the last two sentences were more gibberish than sense here’s the breakdown: The repo tool automatically handles the source code base needed to build a custom ROM. The previous link takes you to a page for the repo tool itself, but you’ll need a shove in the right direction to start using it efficiently.

Head on over to XDA Senior Member Red Devil’s guide on the subject. The original thread, which is part of XDA-University, covers the basics (and then some) in a graphic rich, well organized, and non-bloated way.  After explaining what each part is about, Red Devil shows how to install the tool and use it to automatically pull down the code base. He even hits the GUI version of the folder to show what the file structure looks like after that step. From there, you’ll learn about the XML manifest files that govern how the tool operates on your local copy of the code. Even if you’re already quite comfortable with the repo tool, it’s worth your time to hit the second post in the thread to hear some pro tips.


XDA TV: Most Recent Video

Buy/Sell on Swappa