How to detect existence of landscape version of layout at runtime?

Question

I've search everywhere and can't find any way of doing this at all:

In my project, I have two resources folders for layouts: One is called "layout", and the other is called "layout-land". This is the familiar way of having two separate layouts for each Activity that get used depending on the current orientation. The issue is that I don't have separate "layout-land" layouts for every Activity, and not all Activities even need a different layout for landscape mode.

What I've done is overridden the default onConfigurationChanged to prevent orientation changes from happening (with the appropriate configChanges="orientation" in the manifest). This saved me a lot of headaches stuffing things into Bundles every time the user tilted their screen. However, in some cases, I actually want orientation changes to happen. Whenever there's a corresponding layout in the "layout-land" folder, I want the orientation to change as it normally would. Whenever there isn't, I want onConfigurationChanged to suppress an orientation change event.

I made a parent BaseActivity class that extends Activity and is the base class for all of my activities, and overrode onConfigurationChanged:

@Override
public void onConfigurationChanged(android.content.res.Configuration newConfig)
{
    super.onConfigurationChanged(newConfig);

    if(...there is a layout-land version of the current activity's layout...)
    {
        setRequestedOrientation(newConfig.orientation);
    }
    else
    {
        // Do nothing, since raising the orientation change event
        // to change from a portrait layout to the same portrait layout is silly.
    }
}

The only snag is that I can't find any way of determining if there's a layout-land version of my layout resource. I already know the resource id of the current layout (obtained elsewhere in my BaseActivity class by overriding setContentView), but both the landscape version of the layout and the portrait version share the same id, and I see no easy way for the Resources object to tell me which version of the layout it gives me when I ask it for a specific resource by id. There's got to be a way to do this. What am I missing?

Answer 1

Alright, so I found a solution, albeit a miserable, hacked-together solution. I don't recommend this hack, because it is made of Satan:

The Resources object that you can obtain from an Activity's getResources() method will not by itself tell you if there's a "layout-land" version of a resource. However, you can obtain the AssetManager object that the Resources object uses internally by calling its getAssets() method.

The AssetManager object has a method called openNonAssetFd, which will attempt to grab a file descriptor for a particular file in your res folder. Unfortunately, most (if not all) of the things you attempt to open with this method will throw a FileNotFoundException, even if the file exists!

So, for example, if you have a file called res/layout-land/settings_menu.xml, then it will throw a FileNotFoundException with the message: "This file can not be opened as a file descriptor; it is probably compressed". This is poor design on the part of the Android folks, since technically, the file is there, and the exception thrown should at least be of a different type.

More importantly, however, for the purposes of detecting the mere existence of a layout-land layout, we can rely on the difference in the return messages on the exception thrown. Herein lies the hack:

If the file exists, the exception message will be "This file can not be opened as a file descriptor; it is probably compressed".

If the file doesn't exist, the exception message will be identical to the parameter you passed in to the openNonAssetFd method (i.e., it will be the filename of the nonexistent resource).

Now, with this, we can make a method like so:

protected boolean landscapeLayoutExists(int layoutId)
{
// Since we're always passing in an id of a layout, this will always correspond
// to a layout file in any of the layout folders (either layout, or both layout and layout-land, in my case).
String rawName = this.getResources().getResourceEntryName(layoutId);
String testPath = "res/layout-land/" + rawName + ".xml";

try
{
    this.getResources().getAssets().openNonAssetFd(testPath);
}
catch(Exception ex)
{
    if(ex.getMessage().equals(testPath))
        return false;
    else
        return true;
}   

// Somehow, we managed to grab the file descriptor successfully.  
// In my experience, this cannot happen with layouts, but if it ever does,
// then we definitely know the file exists.
return true;
}

By using this method, I can now determine if there's a version of the current activity's layout in the "layout-land" folder, and act accordingly.

However, I am unsatisfied with this approach, although it does work (for now, at least on the Galaxy S3 I tested this on). If anyone has a better one please let me know.

Answer 2

In your layout in the layout_land folder add an id = layout_name_of_this_file for your outermost FrameLayout. For example

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/layout_name_of_this_file"
    .....

and in your code

getResources().getIdentifier("layout_name_of_this_file", "id", "com.example....")) = resource id of the button (a pretty long number)

and

getResources().getIdentifier("layout_name_of_the_layout_file_exist_in_layout_but_not_in_layout_land", "id", "com.example....")) = 0  

because there is no FrameLayout with this id.