private void setLayout() {
        // Get display for detecting the phone orientation
        final Display display = ((WindowManager) getSystemService(
            WINDOW_SERVICE)).getDefaultDisplay();
        if (display.getRotation() == Surface.ROTATION_0 ||
            display.getRotation() == Surface.ROTATION_180) {
            setContentView(R.layout.home);
        } else {
            setContentView(R.layout.home_l);
        }
    }

P.S.
Actually, ignore code above it will not work. All you really need to do is to detect what is larger – height or width and adjust layout accordingly

    private void setLayout() {
        // Get display for detecting the phone orientation
        final Display display = ((WindowManager)
             getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        final boolean isTall = display.getHeight() > display.getWidth();
        setContentView(isTall ? R.layout.home : R.layout.home_l);
    }

Here’ show your applicationContext.xml (snippet) will look

    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>file:///C:/foo/properties.yaml</value>
        </property>
        <property name="propertiesPersister" ref="persister"></property>
    </bean>
    <bean id="persister" class="com.foo.utils.YamlPropertiesPersister"></bean>

And here’s bare-bone PropertiesPersister implementation using SnakeYaml as parser

public class YamlPropertiesPersister implements PropertiesPersister {
    @Override
    public void load(Properties props, InputStream is) throws IOException {
        load(props, new InputStreamReader(is));
    }

    /**
     * We want to traverse map representing Yaml object and each time we will find String:String value pair we want to
     * save it as Property. As we are going deeper into map we generate a compound key as path-like String
     *
     * @param props
     * @param reader
     * @throws IOException
     * @see org.springframework.util.PropertiesPersister#load(java.util.Properties, java.io.Reader)
     */
    @Override
    public void load(Properties props, Reader reader) throws IOException {
        Yaml yaml = CollectorUtils.instanceOfYaml();
        Map<String, Object> map = (Map<String, Object>) yaml.load(reader);
        // now we can populate supplied props
        assignProperties(props, map, null);
    }

    /**
     * @param props
     * @param map
     */
    public void assignProperties(Properties props, Map<String, Object> map, String path) {
        for (Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            if (StringUtils.isNotEmpty(path))
                key = path + "." + key;
            Object val = entry.getValue();
            if (val instanceof String) {
                // see if we need to create a compound key
                props.put(key, val);
            } else if (val instanceof Map) {
                assignProperties(props, (Map<String, Object>) val, key);
            }
        }
    }

    @Override
    public void store(Properties props, OutputStream os, String header) throws IOException {
        throw new NotImplementedException("Current implementation is a read-only");
    }

    @Override
    public void store(Properties props, Writer writer, String header) throws IOException {
        throw new NotImplementedException("Current implementation is a read-only");
    }

    @Override
    public void loadFromXml(Properties props, InputStream is) throws IOException {
        throw new NotImplementedException("Use DefaultPropertiesPersister if you want to read/write XML");
    }

    @Override
    public void storeToXml(Properties props, OutputStream os, String header) throws IOException {
        throw new NotImplementedException("Use DefaultPropertiesPersister if you want to load/store to XML");
    }

    @Override
    public void storeToXml(Properties props, OutputStream os, String header, String encoding) throws IOException {
        throw new NotImplementedException("Use DefaultPropertiesPersister if you want to read/write XML");
    }
}

And as an added bonus, here’s how you create Yaml instance with SnakeYaml

    public static Yaml instanceOfYaml() {
        DumperOptions options = new DumperOptions();
        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
        options.setDefaultScalarStyle(ScalarStyle.DOUBLE_QUOTED);
        final Yaml yaml = new Yaml(new Loader(), new Dumper(options), new Resolver() {
            /**
             * @see org.yaml.snakeyaml.resolver.Resolver#addImplicitResolvers()
             */
            @Override
            protected void addImplicitResolvers() {
                addImplicitResolver(Tag.BOOL, BOOL, "yYnNtTfFoO");
                // disable resolving of floats and integers
                // addImplicitResolver(Tags.FLOAT, FLOAT, "-+0123456789.");
                // addImplicitResolver(Tag.INT, INT, "-+0123456789");
                addImplicitResolver(Tag.MERGE, MERGE, "<");
                addImplicitResolver(Tag.NULL, NULL, "~nN\0");
                addImplicitResolver(Tag.NULL, EMPTY, null);
                addImplicitResolver(Tag.TIMESTAMP, TIMESTAMP, "0123456789");
                addImplicitResolver(Tag.VALUE, VALUE, "=");
            }
        });
        return yaml;
    }

1. Loop through the list and for each slot
   1. Compare current value with the given value
   2. If match is found modify current item and break the loop
2. If the given value wasn’t find in the loop add it to the list

Turns out breaking out of loops using labels also works for curly block of code so the solution is below

List list = getFromSomewhere();
Foo foo = whatever();
gotu: {
    for (Foo f : list) {
        if ( f.equals(foo)) {
            f.setBlah(foo.getBlah()); // blah is not used in compare()
            break gotu;
       }
    }
// only want to execute the following if the loop was never broken
list.add(foo);
}

1. Define private static final MyUtils filed
2. Place your utility method code inside a “regular” protected method
3. Make your public static utility method refer to the internal MyUtils static instance

In code it will look like this

public class MyUtils {
    private static final MyUtils UTILS = new MyUtils();

    /**
     * Hide constructor from the outside of the package
     */
    MyUtils() {}

    public static String parseUpdates(String html) throws IOException, SAXException {
        return UTILS._parseUpdates(html);
    }

    String _parseUpdates(String html) throws IOException, SAXException {
        InputSource s = new InputSource(new StringReader(html));
        SaxParser parser = new SaxParser();
        MyUpdatesHandler handler = new MyUpdatesHandler();
        parser.setContentHandler(handler);
        parser.parse(s);
        return handler.getOutput();
    }
}

With this code now you can now write JUnit test as follows (test class shell and javadoc comments are omitted for briefness)

    MyUtils utils;
    String html;
    @Before
    public void setUp() throws Exception {
        utils = new MyUtils();
        html = "<div>Hello World</div>";
    }

    @Test
    public void testParseUpdates() throws Exception {
        String out = utils._parseUpdates(html);
        assertNotNull(out);
        // any other assertions that make sense
    }

• Never ever execute things of any considerable length on the same (usually main) thread as your current Activity. Your users will be presented with “Wait or Cancel” choice and
  1. They will be annoyed
  2. 90% will click “Cancel” and never use your app ever again
• What to do instead? Spawn the thread, use TimerTask or just plain Runnable and read some good Java concurrency book before you do that
• Learn Services. That’s where the platform truly shines
• Do not add new features before you make your existing one work as intended. And that means: Fix Bugs!
• Yes, yes, I know – it’s boring and you have all these grande ideas, but if you don’t cover your basics well you will loose your users
• Read your feedback. Even from trolls. It will make you angry so put that adrenalin into bug fixing.
• Learn by example. Find good open source project and just see how it’s layout, how it’s designed and implemented. I’ve learn so much from Oauth-Signpost: thank you guys, you are an awesome bunch
• Steal. Yeah – from forums, blogs and Open Source, just try to find something you can use or reuse and use/reuse it!
• Ask questions, lots of questions! Android Developer forums are indispensable and so is http://stackoverflow.com
• Keep coding, you will get it…

To turn the Spinner into image button is easy – in XML definition simply add android:background="@drawable/select" where “select” refers to res/drawable/select.png
However you will now have a problem with the text of selected item overlaying Spinner’s background image. To solve this problem you will have to do some Java coding as follows:

Spinner spin = (Spinner) d.findViewById(R.id.searchCriteria);
spin.setOnItemSelectedListener(new OnItemSelectedListener() {
  public void onItemSelected(AdapterView parent, View view, int
position, long id) {
    // hide selection text
    ((TextView)view).setText(null);
    // if you want you can change background here
  }
  public void onNothingSelected(AdapterView parent) {}

});

1. Activity calls another application
2. Original application terminates (basically I’m trying to simulate a very busy phone)
3. 2nd app calls the original app
4. Original app restarts from scratch and processes callback

So, how you do it? Very simple – just call

System.exit(0)

I’m going to run some tests but my hunch is the app just drops dead, so don’t expect gracious Activity#onStop or even Activity#onDestroy. Or at least that’s what I think, but for my purpose it’s all right

	
		My Datasource
		jdbc/myds
		javax.sql.DataSource
		Container
	

Patterns, Anti-patterns, best and worth practices, etc.

Don’t try too hard with your names (anti-pattern)

When define name for your entities one should be concern with what the entity is rather than how it relates to the different entities. Good example would be a “TestRunResultResultTest” which gives not a slightest hint that this is a POJO (plain old java object) that holds data produced by validation logic applied to the execution of the single shell script. Name like “ValidationResult” would describe this entity much better and don’t produce monsters such as testRunResultResultTestDao.getTestRunResultResultTestForTestRunResult (say it aloud 5 times)

Don’t add features until asked by customer

I’m referring to the validation above which seems to do the same job as test script only it is harder to configure. The following is email that I send out that explains my point of view

AIMV back end that I’m refactoring now has a “Validation” part. In the back end code it’s not really implemented (the only validation there is some hardcoded regexpression applied to stderr output). From what I understand validation is supposed to validate the output produced by the script and should be driven by the database table that holds things like validation type, expected outcome, etc.

Since we can have multiple scripts attached to each test case I have a hard time distinguishing between the validation and having another script in the test case if the existing one(s) does not provide sufficient information. I think for the most cases just the outcome of the individual shell script (exit code) should be sufficient to indicate success of failure. If such script produces the output that needs to be parsed additionally it would be easier for the script writer to add another script and to pipe and parse the outcome. I propose to remove post-validation from the database and the code and instead rely on ability to add multiple scripts to the individual test case. To give user chance to determine “what went wrong” we will provide ability to look at the produced output (stdout and/or stderr) from the front end for each executed script

Unnecessary exposure to external code

Yes, yes – we do use Spring and probably always will. However that doesn’t mean we have to put direct references to the framework classes into our code. Good example is our DAO interfaces where each method throws org.springframework.dao.DataAccessException. There’s actually another reason why it’s wrong: best practice calls for you defining your own exceptions by extending common Java API exceptions. So in the case of DAO method the appropriate way of declaring the DAO exception would be extending java.lang.RuntimeException and choosing appropriate name (like AimvDataAccessException). By doing this our interfaces will stay framework neutral which they should as much as possible

Non-functional screen elements

If you have screen elements that are not functional – it’s probably a good idea to remove or hide these unless you are actively working on it

Never nest your loops

If you have one FOR or WHILE loop nested inside another one it’s time to refactor the internal loop into it’s own method. It dramatically improves readability of the code and promotes the reuse (how many times did you cut/paste your loop today?)

Replace complex logic inside the IF test (not body) with a method

So if you have logic inside your IF parenthesis spilling to the second line its time to grab that code and put in into a local variable or even better – refactor it to a method that returns a boolean. It’s very simple if you are using Eclipse. Just highlight the code and do right-click->Refactor->Exctract Method. So

if (dis == that && (that != this.somethingElse || foo.equals(this.boo)) {
    // do something
}

becomes

if (isThisSane(dis, that, foo)) {
    // do something
}

Copy/Paste as a root of all evil

If you finding yourself copying and pasting parts of your code most likely you are committing a sin-of-sins. Actually there are tools that written just for the purpose of identifying this anti-pattern. Try PMD plugin on your code and you will be very surprised of results. And why not to do it? Copy/paste promotes code duplication which leads to linear, procedural, spaghetti-like and hard to maintain code. Before you copy/paste see if you can extract reusable method or even class and then it’s perfectly fine to reuse that.

Why coding standards are important?

If the standards were followed then we wouldn’t have Script_Packages.java and ScriptPackage.java in the same folder.

Don’t make your models too special

Models ahould be POJOs with no 3rd party dependencies. For example, we have Script domain object that extends Package. That one in turn implements JSONSerializable interface. As result – backend application has to include json.jar as one of dependencies

DO NOT (Sorry I’m yelling) use System.out.println

Why? I’ll give you 3 reasons

• You are not using debugger, which means you are operating at 20% of your potential productivity
• You are not using logging facilities (Java logging or Log4j) which in a turn means that you are polluting your code left and right and the only choice you have is to remove sysouts manually or leave these in code which will slow your code down
• It’s not cool
  Generally sysouts should not be substitutes for tool-based debugging, and you should have carefully though through logging statements in strategic places that should be permanent part of your code. Verbosity of your log should not be regulated by cut and paste but rather by setting debug level in configuration file

Do not swallow your exception

The exception handling will be eventually put in the separate article but most importantly follow these simple rules:

• Rethrow (or wrap into RuntimeException) your exceptions and let them “bubble up”
• If catching and rethrowing (wrapping) do not forget to pass original exception as an argument (or you will loose stacktrace and messages)
• When you finally deal with the exception, inside your CATCH block use LOG.error(Exception) or at very least e.printStackTrace(). If you don’t, your log will never reflect the valuable information