Given the amount of coverage that Android receives around here, you could almost be forgiven for forgetting that other mobile operating systems do exist. They do, and one of the more recent platforms that is being eagerly anticipated by many that does in fact look promising is Sailfish OS. This OS is the work of a Finnish company called Jolla.

After Nokia’s decision to ditch the Meego operating system, which was developed in conjunction with Intel, in favor of Windows Phone devices; a number of employees decided that continuing to work with Meego and not Nokia was the way forward. This splinter group later became Jolla, and Sailfish OS is based heavily on the Mer Project, a key component of Meego.

Their eponymously named first and therefore flagship device was unveiled recently at the rather curiously titled “Jolla Loveday” event. It showed us not only the hardware that we can expect to see in stores at some point before the end of the year, but also what looks to be a spruced up version of the software itself with some changes to the user interface and a more polished look than anything seen previously.

The device itself looks a lot like an N9, as you might have expected, and why shouldn’t it? That was a fantastic looking device. It has no physical buttons (on the front at least), which can only mean that navigation will be performed by gestures on the device’s 4.5″ screen. This is no doubt similar to the gesture navigation featured in Canonical’s Ubuntu Touch mobile OS. Internally, the device will feature an as yet unspecified dual core processor, 16 GB of internal storage with a microSD card slot available, an 8 MP rear facing camera, removable battery, and 4G capabilities.  It’s also possible to give your device a little personality by making use of a feature which is being referred to as “The Other Half.” These are different coloured  attachments for the rear of the device, which not only add a splash of color to the hardware, but will also reportedly affect the software and alter the theme of the UI to match the attachment. Now if you ask me, that’s pretty cool.

Did I mention that it also runs Android apps? Well it does, in addition to the native Sailfish apps that the company is striving to get developers working on. The device will also have an advantage on its competitors by being able to tap into the huge selection of already available Android applications.

Priced at around €399 (just over $500 give or take a few bucks), the device is not exactly a budget option. But once subsidized by networks, it may end up being an appealing option for quite a few people. For those who would consider buying off contract, pre-ordering will get you a €100 rebate. Whether this will turn out to be a serious Android competitor, the best of the rest, or just a total flop remains to be seen. However, this device has certainly grabbed my attention. Let us know what you think in the comments.

Having a good recovery makes the process of modifying, tweaking, maintaining, and backing up your Android device much easier, so that you don’t have to go through the procedures manually. Installing a recovery is probably one of the main activities for a newly rooted phone, along with installing new firmware and a couple of other essential mods. But what happens when your new phone doesn’t have a CWM to install?

The ‘How to Port CWM to New Devices‘ guide at XDA-University thoroughly covers the procedure of doing exactly what you think: porting CWM to new devices. It’s not an entirely simple, requiring a suitable build environment, but fear not, as the guide does do a good job at detailing the steps that you have to go through. Using the source code of CyanogenMod 10 to build CWM 6, the guide breaks down each step of the compilation process accompanied by examples of code and helpful definitions of terms you may never have heard of. Once all done, you will have the resulting recovery.img that you then flash onto your device using Android Debug Bridge (ADB).

The whole process is estimated to take about 15 minutes, but of course, this will change depending on factors such as level of skill and experience.

If you would like to give this a go, make sure to visit the porting guide at XDA-University.

When my family and I decided to vacation in Park City, we decided to look into renting a condo or vacation home instead of a couple of hotel rooms. We all wanted to be in the same place, and we also wanted to have plenty of room to move around. There are eight of us, so we decided to look at park city vacation homes on the Internet. I think we were all surprised that there were so many, which was nice for us. It meant that we would be able to get exactly what we wanted. Since my husband loves to golf, I decided to look at the vacation homes that border the golf course that he had already researched online.

When I found a three bedroom, three bathroom condo that is right next to the golf course, I knew that we were going to rent that one for the week we would be there. It was close enough to everything else too, so it was in the perfect location. The price was also very attractive, and the rooms were large enough so we would all be comfortable.

I showed the kids some of the amenities there, and they were pleased with the condo that I picked out. Not only was it close to the attractions that we were interested in, but there was also a large swimming pool, gorgeous and spacious decks, a hot tub, a fireplace, and a really nice theater system. With all of the amenities that were offered, I just hoped that the kids would want to leave the house to go explore the attractions that drew us to Park City in the first place. I didn’t have to worry though. We spent our days having all kinds of fun there, and the evening hours were spent in the condo growing closer together as a family. It was the best family vacation we have ever had.

The Push, our new blog, is all about covering the platforms, trends and strategies shaping mobile. It’s staffed by the Mutual Mobile team, some tech bloggers we’ve gotten to know and content creators at partners like SAP.

Here are a few recent articles:

• Developing Google Glassware
• Projected interfaces make touchscreens so 2008
• User-centered design: the biggest “duh” moment in tech
• Car tech: users aren’t the problem

We’ll be updating the site regularly, so check back often for the latest mobile POVs.

The post Introducing The Push appeared first on Mutual Mobile.

While the Galaxy Tab 3 hasn’t been on the forefront of many of our minds here at AndroidPIT (http://www.androidpit.com/5-reasons-why-the-galaxy-tab-3-sucks), it’s always refreshing to see some surprising news that has to do with the lackluster tablet. While the release of the expected tablet has been delayed for a bit over the last little while, it seems that Samsung may have pulled something from their sleeve. 

Hey there Tab! What's new with you? / © Samsung

(This is a preview - click here to read the entire entry.)

PikPok and Dreamworks Team Up for Turbo Racing League

Most people think of snails as slow, slimly creatures and we’d have to agree. Unless you’re talking about the snails of the Turbo Racing League that is. They may be slimy, but they’re the quickest snails you’ve ever seen…

Android Games

For quite some time now, rumours have been flying around in regards to a more rugged version of the Galaxy S4.. With the release of these recent photos of the fabled Samsung Galaxy S4 Active, it looks like the dust and water resistant brother to the Galaxy S4 is on the horizon.

Three physical buttons grace the bottom of the Galaxy S4 Active / © GSM Arena

(This is a preview - click here to read the entire entry.)

A little bit of serendipity hit my inbox yesterday. On Saturday, while looking for something to do, my wife suggested we play video games. Fine by me. She rummaged through our drawer of PS3 games and nonchalantly said, “We have You Don’t Know Jack, but I’d just wipe the floor with you anyway.” Game on. We played, and she beat me — she always does. It reminded me of just how much I love that kooky little quiz game.

Much to my joy, a press release showed up in my inbox this morning touting the availability of You Don’t Know Jack for Android. You might remember a YDNJ announcement from last year, when developer Jellyvision launched a Facebook version. That took home some awards, and is now also available on iOS. The Android version plugs into these networks, creating an even larger online community.

If you’ve never played YDNJ, there’s not much I can do for you at this point. The game is definitely a little wacky, which helps it stand out from your run of the mill quiz games. There are many different types of questions, so you’re not just answering multiple choice queries all day. And yes, you’ll get insulted if you answer incorrectly.

(Or you’ll get the Wrong Answer of the Day and turn a $2,000 loss into an $8,000 gain.)

Back in the day, YDNJ worked great on PC, because in those days you would gather your friends all in one place to play video games. Ah yes, the days when we played four-player Goldeneye on a 25-inch TV. Alas, these days video games are played online, which means you can play your friends no matter where your locale. It will certainly be nice to play YDNJ again with my old high school buddies.

As with most things Android, YDNJ is free. You can download it from Google Play.

The post You Don’t Know Jack Now Available for Android appeared first on MobileMoo.

A key focus of Google Wallet is to simplify commerce for merchants and shoppers; for over a year now, consumers on Google Play have been using Wallet to make their purchases, to the benefit of the entire ecosystem. Helping merchants benefit from the growing consumer adoption of mobile commerce is where we believe we can make the most impact. And that’s why today we're focusing our efforts on the new Google Wallet Merchant Center and retiring Google Checkout over the next six months.

Most Google Play apps developers will seamlessly transition to the Wallet Merchant Center, which provides new reporting and analytics features and much more. A small number of Google Play developers, however, will see some changes:

• Developers using Google Checkout on their website to sell physical goods or services will no longer be able to use Checkout after November 20, 2013. We have provided some discounted migration options to help with this change. If you are a U.S. merchant selling physical goods and services who does have payment processing, you can apply for Google Wallet Instant Buy, which offers a fast buying experience to Google Wallet shoppers.
• Developers who use the Google Checkout for the Notifications and/or Order Reports API(s) will need to migrate to replacement APIs, made available through Google Play, before November 20, 2013. Watch for announcements on the new APIs soon.

If you sell apps or in-app products in Google Play, you’ll soon have access to the new Wallet Merchant Center. Watch for an email notifying you that that it’s now available to you. We expect to transition all merchants to the Wallet Merchant Center over the next several weeks.

We invite you to join us for our live merchant webinar on May 23, 2013 at 10AM PDT to learn more and ask any outstanding questions. As always, feel free to contact us at any time during this transition. Finally, be sure to check out the exciting updates launched last week at Google I/O (including Instant Buy and Wallet Objects) and stay tuned for more great developer features coming soon!

Covering the biggest news in mobile, in just around a minute.

This week, we had a chance to try out Google Glass. It made us wonder, “Will Glass go mainstream or is it just a toy for the tech elite?”

The post Mobile Minute: May 20 appeared first on Mutual Mobile.

We reported a few times in the past that Peter Molyneux's studios 22Cans, the folks responsibly for the Curiosity game, happen to be working on a new game called Godus. This particular game is sort of a mix between Populous and Dungeon Keeper with 3D visuals to round everything off.

Players will be playing as a god-type deity who will be will be shaping their kingdom and lands, while engaging into rather deep multiplayer combat gameplay that is more in the style of Dungeon Keeper but against rival gods (other players). The game's development is coming along just fine and it still has a way to go before it is done.

However news today is that 22Cans has signed a partnership deal with DeNA to have the company publish their game when it is done. This means it will arrive under the Mobage brand which is DeNA's social gaming platform. While this will help with social features and the multiplayer aspects, this also means it will be a free-to-play game. It also means that there will also be optional IAPs in Godus although we are not exactly sure right now what those will be.

As for when this game will be released, there is no set release date as of yet.

Developer Website: 22Cans

A Kickstarter project is now up and running for a rather interesting, and conceptually amazing, application that will allow anyone using graph paper and a pencil to literally draw their own game. From the designs on the graph paper that you have drawn, the application will read that and convert it into a game which you can then share with your friends.

While the original goal of Pixel Press is for an iOS application, there are new and pretty small stretch goals that would bring the application to Android as well. At $125,000, the developers will make both an Android and an iOS version. If they hit $150,000 in funding, we can expect an Ouya version, upload graphics and images features, and alter physics as well which is pretty damn interesting in itself.

The entire process of drawing your own game takes four steps: draw a level, take a picture, design it, play & share. While there are some questions as to how much logic can be implemented into the game from within the application when it converts it to a game, the application will be ever expanding to include new mechanics and features for you to use when designing your levels with the tools the application comes with.

If you're up for ensuring that an Android version of this application comes to life, head on over to the Pixel Press Kickstarter page and toss a couple of bucks their way to help out. If you have any questions, the developers are actually holding an IAmA on Reddit all day today so head over there if you have any questions or concerns. You can also watch a demo video above.

Website Referenced: Pixel Press bKickstart

Offical Website: Pixel Press

In Reto Meier’s 2013 Google I|O presentation, he referred to a concept he called the “uncanny app valley”. While most incarnations of the “uncanny valley” refer to UI, his “uncanny app valley” refers to permissions and general creepiness. Mr. Meier had a slide in his presentation depicting a generalized creepiness chart, complete with a valley representing a creepy app, and with an upslope to the right showing apps that know a lot about you but, in Mr. Meier’s eyes, are not creepy at all. In particular, Google Now was his example of a non-creepy app.

I found that to be a curious example, considering that I went to the level of disabling Google Search on my Galaxy Nexus just to get rid of Google Now, as it is entirely too creepy for my taste.

The truth of the matter is that there is no universal creepiness curve. Different people will have different attitudes towards privacy. Some will not worry a whit about it, aiming for maximum app capability. Others will find Google Now and similar apps to be too invasive.

Branding will have a lot to do with it as well. Apps from brands that users trust will be more likely to escape the “uncanny app valley” than will apps from unrecognized developers or brands that are not trustworthy. So, for example, I am willing to give Evernote a lot of permissions that I do not give out otherwise. At the same time I am still hunting for a decent Twitter client that does not ask for the sun, moon, and stars from a permission standpoint. I have greater trust in Evernote than I do in Twitter, and I have greater trust in Twitter’s own apps than I do closed-source high-permission Twitter clients from other developers.

(Murphy’s Law, of course, suggests that Evernote will get acquired by somebody I distrust at some inopportune moment…)

Hence, while Mr. Meier advocates things like location tracking to help apps deliver “magic”, that may not be in your best interests. Each additional permission that you request serves as a filter, with some percentage of your potential audience electing not to install your app due to that permission. How big that percentage is will vary, based upon permission, branding, available substitute apps, and so forth.

Savvy developers will consider allowing users to “dial in” the amount of privacy they are willing to give up, by delegating privacy-invading permissions to plugins. Since Google has demonstrated no interest in allowing users to control permissions individually per app (and since only so many people run ROM mods that offer this), plugins are a likely approach for keeping your main app light on permissions, yet allowing users to opt into additional functionality with only a bit more work on their part. Cutting the work for developers to support this sort of plugin model is on my ever-popular to-do list…

Certainly, “magic” is an app implementation metaphor of some value. However, if giving your app “magic” means raising privacy and security concerns in prospective users, consider how you can best mitigate those concerns, either by adopting a plugin model, or trying to balance exactly how “magical” your app becomes.

Today’s post is about animation, a beautiful animation, exploring capabilities of android.

You can click on the link to download the code.

Here we will have three java classes and no XML files.
1. GraphicsActivity.java
2. PictureLayout.java
3. Sweep.java

At first we start with PictureLayout.java

package com.example.sweep;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Picture;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;

public class PictureLayout extends ViewGroup {
    private final Picture mPicture = new Picture();

    public PictureLayout(Context context) {
        super(context);
    }

    public PictureLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    public void addView(View child) {
        if (getChildCount() > 1) {
            throw new IllegalStateException("PictureLayout can host only one direct child");
        }

        super.addView(child);
    }

    @Override
    public void addView(View child, int index) {
        if (getChildCount() > 1) {
            throw new IllegalStateException("PictureLayout can host only one direct child");
        }

        super.addView(child, index);
    }

    @Override
    public void addView(View child, LayoutParams params) {
        if (getChildCount() > 1) {
            throw new IllegalStateException("PictureLayout can host only one direct child");
        }

        super.addView(child, params);
    }

    @Override
    public void addView(View child, int index, LayoutParams params) {
        if (getChildCount() > 1) {
            throw new IllegalStateException("PictureLayout can host only one direct child");
        }

        super.addView(child, index, params);
    }

    @Override
    protected LayoutParams generateDefaultLayoutParams() {
        return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final int count = getChildCount();

        int maxHeight = 0;
        int maxWidth = 0;

        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                measureChild(child, widthMeasureSpec, heightMeasureSpec);
            }
        }

        maxWidth += getPaddingLeft() + getPaddingRight();
        maxHeight += getPaddingTop() + getPaddingBottom();

        Drawable drawable = getBackground();
        if (drawable != null) {
            maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
            maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
        }

        setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec),
                resolveSize(maxHeight, heightMeasureSpec));
    }

    private void drawPict(Canvas canvas, int x, int y, int w, int h,
                          float sx, float sy) {
        canvas.save();
        canvas.translate(x, y);
        canvas.clipRect(0, 0, w, h);
        canvas.scale(0.5f, 0.5f);
        canvas.scale(sx, sy, w, h);
        canvas.drawPicture(mPicture);
        canvas.restore();
    }

    @SuppressWarnings("unused")
	@Override
    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(mPicture.beginRecording(getWidth(), getHeight()));
        mPicture.endRecording();

        int x = getWidth()/2;
        int y = getHeight()/2;

        if (false) {
            canvas.drawPicture(mPicture);
        } else {
            drawPict(canvas, 0, 0, x, y,  1,  1);
            drawPict(canvas, x, 0, x, y, -1,  1);
            drawPict(canvas, 0, y, x, y,  1, -1);
            drawPict(canvas, x, y, x, y, -1, -1);
        }
    }

    @Override
    public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
        location[0] = getLeft();
        location[1] = getTop();
        dirty.set(0, 0, getWidth(), getHeight());
        return getParent();
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        final int count = super.getChildCount();

        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                final int childLeft = getPaddingLeft();
                final int childTop = getPaddingTop();
                child.layout(childLeft, childTop,
                        childLeft + child.getMeasuredWidth(),
                        childTop + child.getMeasuredHeight());

            }
        }
    }
}

Now our second java file, GraphicsActivity.java
No need to declare this activity in the Manifest since you are only extending it.

package com.example.sweep;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;

class GraphicsActivity extends Activity {
    // set to true to test Picture
    private static final boolean TEST_PICTURE = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public void setContentView(View view) {
        if (TEST_PICTURE) {
            ViewGroup vg = new PictureLayout(this);
            vg.addView(view);
            view = vg;
        }

        super.setContentView(view);
    }
}

Now the last java class that extends the GraphicsActivity and creates the animation.
Sweep.java

package com.example.sweep;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Shader;
import android.graphics.SweepGradient;
import android.os.Bundle;
import android.view.View;

public class Sweep extends GraphicsActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new SampleView(this));
    }

    private static class SampleView extends View {
        private Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        private float mRotate;
        private Matrix mMatrix = new Matrix();
        private Shader mShader;
        private boolean mDoTiming;

        public SampleView(Context context) {
            super(context);
            setFocusable(true);
            setFocusableInTouchMode(true);

            float x = 160;
            float y = 100;
            mShader = new SweepGradient(x, y, new int[] { Color.GREEN,
                                                  Color.RED,
                                                  Color.BLUE,
                                                  Color.GREEN }, null);
            mPaint.setShader(mShader);
        }

        @Override protected void onDraw(Canvas canvas) {
            Paint paint = mPaint;
            float x = 160;
            float y = 100;

            canvas.drawColor(Color.WHITE);

            mMatrix.setRotate(mRotate, x, y);
            mShader.setLocalMatrix(mMatrix);
            mRotate += 3;
            if (mRotate >= 360) {
                mRotate = 0;
            }
            invalidate();

            if (mDoTiming) {
                long now = System.currentTimeMillis();
                for (int i = 0; i < 20; i++) {
                    canvas.drawCircle(x, y, 80, paint);
                }
                now = System.currentTimeMillis() - now;
                android.util.Log.d("skia", "sweep ms = " + (now/20.));
            }
            else {
                canvas.drawCircle(x, y, 80, paint);
            }
        }

       
    }
}

Please leave your valuable comments on this post.

You can download the source code for the above post from here.

Google I/O 2013 is almost over but a lot of sessions are already available online. I gave three talks this year and you can watch them today on YouTube:

• Writing Custom Views for Android, with Adam Powell
• A Moving Experience, with Chet Haase
• Android Graphics Performance, with Chet Haase

In addition you can download the slide for the Android Graphics Performance talk:

• Keynote (7MB)
• PDF (13MB)
• PDF with notes (13MB)

And the slides for A Moving Experience:

• Keynote (7MB)
• PDF (13MB)
• PDF with notes (13MB)

If you have a copy of Keynote I recommend you choose this format to get both the notes and all the animations on the slides. Enjoy!

• Keynote
• PDF
• PDF with speaker notes

Posted by Ellie Powers, Google Play team

This week at I/O, we were excited to announce some updates to Google Play to help you optimize your business on Google Play: to help you take control of your app publishing, gain insight into your users, and expand your app’s success globally.

Play Store’s new view: apps designed for tablets

Many of you have invested in making great tablet experiences for your users, and we want to ensure that that work pays off and that users are able to discover great apps for their tablets. This week, the Google Play store began providing a view of our top charts highlighting apps which have been designed for tablets according to our tablet app quality checklist.

Be sure you don’t miss out! Check that your app’s optimization tips say that your app is designed for tablets, and upload tablet screenshots for 7” and 10” tablets.

Beta testing and staged rollouts

We have introduced support for beta testing and staged rollouts so that you can get feedback on your new app or app update early in its development and make sure your users are happy with the results. You can test two different versions on two different groups at the same time, such as testing a newer version with your employees first, and a more mature version with a group of external testers.

The beta testing is private on Google Play, and you can specify who gets these versions by adding Google Groups and Google+ Communities. Users give you feedback privately rather than through public reviews. When you’re satisfied that your new version is ready, you can now do a staged rollout to a percentage of your userbase. To give you more flexibility in light of beta testing and help get your whole team involved in the Developer Console, we will soon launch additional access controls.

Localization improvements

We’re collaborating with Google's internationalization team to make translating your app into new languages easier than ever. You can purchase professional translations of your apps from independent providers through the Google Play Developer Console. You can upload the strings you want translated, select the languages you want to translate into, and select your translation vendor based on time and price. If you’re interested in translating your apps with this feature, sign up to be a part of the preview in the Developer Console today on the APK page.

The new optimization tips for localization will help you identify new potential opportunities for global expansion based on popular languages for your app’s users and category. To fully localize your app into a language, you need to translate the strings in an APK, translate your Google Play store listing, and upload localized graphics. The optimization tips will also let you know if you’re missing any of these pieces.

New Analytics and monetization features

Getting better revenue and engagement data has been another key developer request, as developers told us that they check their revenue and stats constantly. New revenue charts in the Developer Console allow you to see your app’s daily revenue and summary figures, and you can filter the data by country. Coming soon, Google Play and Google Analytics are teaming up to bring you better insight into your users. Google Analytics will start showing Google Play views and installs for each campaign, while Google Play will show Google Analytics engagement metrics.

For those of you using in-app billing, we’ve heard your feedback and made some improvements to reduce your development time and costs. Your test accounts will now able to make in-app test purchases without those transactions actually being charged, but everything else works the same as it would for a real user.

In a few weeks, we will launch a new Order Status API, which allows you to verify the status of an in-app order from your servers. We will also be launching a tool for automating downloads of financial reports. Finally, the new Google Wallet Merchant Center is continuing to roll out with enhanced reporting, additional analytics and many other enhancements.

Google Play for Education coming soon

You'll soon be able to offer apps to schools through Google Play for Education, which launches later this year to K-12 schools in the United States. This online destination will allow schools to discover, purchase, and distribute apps to their students. Visit developer.android.com/edu to get started creating or optimizing your apps for schools today.

Join the discussion on

+Android Developers

In yesterday’s piece on the Google Galaxy S4, commenter TurboFool asked me an interesting question: “Are you completely unaware if [sic] the huge market of prepaid SIM-only carriers so many of us are switching to now?” As the guy who also runs Prepaid Reviews, I’m certainly aware that these services exist. At the same time, I’m not sure I’d spend $650 on a device like the S4 and bring it to one of these carriers.

(His point about stock Android stands, though. I know plenty of people who rooted their Galaxy S3 models just to get rid of the TouchWiz UI.)

The problem with the SIM-only deals is that they typically do not offer LTE speeds. A few T-Mobile MVNOs have said they will offer LTE when T-Mobile makes it available to them, but there’s no guarantee on that. There are, to be sure, a few MVNOs that offer HSPA speeds of 21 or 42 MBPS, and those can provide speeds that can at least compete in LTE’s ballpark (and depending on your region might be your best bet). So yes, there are options beyond the Big Four. I’m just not sure if I consider them ideal.

Yet SIM-only deals aren’y the only prepaid ones to be had these days. In recent years Straight Talk, a Tracfone brand, has taken off in a major way. That’ll happen when you offer unlimited everything for $45, and a reasonable plan for $30 per month. Make no mistake: unlimited data is absolutely not unlimited on Straight Talk. They throttle speeds for excessive users. But it’s still tough to ignore the price tag for monthly service.

Right now Straight Talk is running a promotion for free ground shipping on any phone order over $29.99. If you’re going for the $45 plan, you won’t find much worth buying under $30, so there’s your free shipping. They have an array of models, from the Galaxy S3 on down. They also have deals with the Big Four networks, so you might get a Verizon-network phone, rather than a T-Mobile one.

The post Deal: Free Shipping on any Straight Talk Phone appeared first on MobileMoo.

The game that changed the world and helped make it a better place for the following five or six years has arrived on Android, thanks to Sega publishing its first ever OFFICIAL version of the original 2D Sonic game for Google phone users.

Obviously you’ve been able to play Sonic 1 on Android for years via a number of top quality emulators, but this is the legal, easier way. Sega says we can expect to see widescreen image support, Tails and Knuckles as unlockable characters (SACRILEGE) and the spin-dash move from later Sonics (ALSO SACRILEGE). Here it is:

Sonic 1 is on the Play Store for £2.35. We haven’t yet but probably will soon.

It’s been less than 24 hours since the Android Studio “early access preview” was released, and IMHO way too many people are trying it, based on the flood of questions coming into StackOverflow.

IMHO, to be using Android Studio today, you either need to:

• Be a current user of IntelliJ IDEA, so that you know how the basic IDE should work and can see where IDEA ends, Android Studio begins, and on which side any particular problems with Android Studio lie, or

• Be a very expert software developer, with experience in a variety of IDEs, above and beyond a year or more of Android programming experience

If you do not fit into one of those two buckets, leave Android Studio alone for the time being.

If you want to start getting a feel for what Android Studio will do for you, try out IntelliJ IDEA. The open source Community Edition already has a fair bit of Android development integration, just not as much as Android Studio will eventually offer. Later on, when you are fairly comfortable with IDEA, Android Studio hopefully will have matured enough that it will be worth your experimentation.

If you are an IntelliJ user, or are a seasoned veteran, and you want to start experimenting with Android Studio, be my guest. Just bear in mind that this is a 0.1 release, and as Xav and Tor mentioned in the Google I|O presentation, Android Studio is broken in many places. More so than is normal in Android, the expression “your mileage may vary” applies. You might consider trying the IDEA 13 early access preview first, as I get the impression that Android Studio is based upon it, so if IDEA 13 is giving you grief, Android Studio is likely to give you yet more grief.

Google’s Android OS has more than 900 million users, the company said Wednesday at its I/O event began in San Francisco.

Google also announced several APIs that will let developers add more capabilities to their Android apps, including in the areas of location and improving battery life.

“It’s been an amazing year for Android developers,” said Android and Chrome vice president Sundar Piachai.

Read More from here.
http://www.pcworld.com/article/2038798/google-says-it-has-900-million-android-activations.html

Finally Google Play allows developers to write responses to comments in the store, previously this function had been reserved only for Top Developers. Lately more and more devs reported that they can reply to comments, but this was only a staggered rollout until now. They officially announced the feature on Android Developers Blog. Now you can forget the well known solution when devs asking users in the app description to send an e-mail if they have any problems, questions or suggestions. Now the communication can be much easier between the companies and the customers.

read more

Don’t look for any big new hardware or major releases in Android at Google I/O this week, it’s likely not going to happen. Google’s Sundar Pinchai, speaking with Wired, tells us that Google I/O is “going to be different” this year.

read more

This is one of the best ideas for an app we’ve encountered for a long time. Service Saver is designed for UK motorway travellers, pointing out nearby off-motorway supermarkets, and therefore enabling drivers to avoid the MISERY that is paying £3.49 for a cup of tea and £4.69 for a limp egg mayo sandwich in some hellish service station. Google Maps integration simply directs you to the nearest supermarket instead. Result.

There’s a free version of the app too, which, according to user reviews, works perfectly well but is a little vague when it comes to naming the actual brand of supermarket…

…but still gets the job done. And, as plenty of users point out, filling up your car at supermarket cost rather than service station prices should mean the app pays for itself on your first trip. And you can earn your Nectar points, too.

Interest. Mortgage interest payments on the loan to obtain the rental home are a deductible co…

As a landlord, you will want to make positive you take benefit of all of the tax benefits you can acquire by owning a home. There are several other deductions than just the apparent ones. Costs incurred to cancel a lease, reimbursements to renters for costs that they have incurred and many others exist. Make certain you are taking benefit of all of the expenses you have.

Interest. Mortgage interest payments on the loan to purchase the rental home are a deductible price, but make positive you also deduct interest on loans for improvements to the home, as properly as credit card interest for credit card accounts you use to purchase any items or solutions for the home. Interest can be 1 of the biggest deductible costs for a landlord.

Depreciation. The price of your house is recovered more than time via depreciation. Right after the second year of ownership, you can claim depreciation over a 27.5 year period.

Repairs. Any repairs you make to the rental home are deductible expenditures in the year the expense occurs. These contain painting, replacing broken windows, hiring a plumber to repair leaks, placing new flooring down, plastering walls. To qualify, you have to make sure the costs are ordinary expenditures in the price of operating the rental home, affordable fees and not capital improvements.

Travel. If you have to travel to your rental house to gather rent, go over troubles with renters, attend renter association meetings or carry out repairs, you can deduct the expense of this travel. If you have to visit service providers such as plumbers or electricians, you can deduct that as nicely. If you are travelling from a distance, you can deduct the expense of your hotel as properly.

Property Office. If you use a space in your house as an office to conduct the business of operating your rentals, that portion of your personal rent or mortgage is deductible.

Losses. You can claim any losses as deductions. These include fire and weather damage or floods. If you have insurance coverage, you can only deduct the non-reimbursed portion, of course.

Insurance coverage. The premiums you spend on your home insurance coverage is deductible. You will most likely have flood, fire, theft and liability insurance coverage on the house.

Services. Any type of charges you spend for solutions connected to the home are deductible, such as lawyer charges, accountant fees, payments to property management firms, actual estate investment advisors and other pros who supply you solutions to appropriately manage your rental house.

Some expenditures that you might have are not deductible, nevertheless. If you have a loss of rental due to vacancy are not deductible, and specific modifications that are capital in nature such as a new roof, room additions, a new fence, and so on. are not deductible.

accountant kansas city

Swing for the Fences in Baseball Hero from Doodle Mobile

The baseball season kicked off in April, and since then we’ve seen several new Android Apps and Games pop up on Google Play. Baseball Hero is the latest baseball game to come our way, and it’s been a surprise hit among our staff over the past several days. Baseball Hero drops you onto the diamond where you’ll get to bat and pitch as you try to make it from a Rookie to a seasoned Major League Pro. It’s a simple take on America’s pastime, but effective as the way you go about pitching and hitting is super simple and quite a bit of fun. Baseball Hero has you swipe patterns to hit different types of pitches; the same goes for pitching as you’ll basically connect-the-dots to throw a curve ball or slider. There are three different modes of play, and while the graphics may not be jaw-dropping they are easy on the eyes. Baseball Hero is the first game I’ve played by the folks from Doodle Mobile, but it won’t be the last as I’ve been impressed with what I’ve seen so far. It’s not a full-fledged baseball game, but Career Mode and the way the controls are set up make it a game you’re going to want to pick up. Baseball Hero is simple to play, hard to put down, and free to download on Google Play.    

Android Games

We have launched our newly designed Android market app, version 5 of the SlideME Application Manager (SAM), and we wanted to highlight some of the new features that you might not yet know about in the new SAM 5. 

 

Thanks to community and tester effort, SAM 5 has already reached its 13th version (5.13) with tons of stability, performance, and usability improvements, easily making it the best SAM (yet). 

read more

In October 2012, I released a library called Polaris. At that time, the library received quite a lot of success because it was really filling the mammoth blanks of the Google Maps external library (aka Google Maps Android API v1): effortless map annotation, gesture support, map callout support, built-in “user tracking” mode, etc. If you have never heard of Polaris feel free to checkout one of the links below:

• Polaris GitHub page
• “Meet Polaris, a Map Library for Android” blog post
• “Polaris, simple mapping library for Android” slides

(Un)fortunately - the addition/removal of the ‘un’ obviously depends on the point of view - Google released a radically different and new version of the library in December 2012. In addition to this release they announced the deprecation of the first version of the API as of March 2013¹. Let’s be honest, at first I was pretty annoyed by this new release because it turned almost all of my work to a waste of time. On the other hand, I was quite happy to notice the new API were really close - functionaly and API-ly speaking - to what I did on my own with Polaris.

Back in December I gave my point of view about the new Google Maps Android API v2. After almost 6 months, the library has been updated only once (as part of the Google Play Service, it was supposed to be updated very often…) and is not a great starting base for building libraries on top of it (all of the classes are final and hence cannot be extended).

With the release of AVélov 1.2, a lot of people were interested in the animated clustering algorithm I developed. Several companies asked me for the app source code and I was quite frustrated not being able to deliver a true library but only a sample code. That was true until I decided to find a way around the Google’s locked down library. I finally managed to by-pass the ‘final’ limitation fairly easily. I entirely wrapped the original Google’s library into my own library: Polaris v2.

Introducing Polaris v2

The main purpose of Polaris v2 is to act as the root component for creating library projects around the Google Maps Android API v2. Although I originally developed it for creating commercial library providing animated clustering, I extracted the essence of it and kept some basic features. As a consequence, Polaris v2 aims to fix some of the most frustrating bugs of the original library and provide additional features.

For now, the code is mostly a wrapper but I’m releasing and open-sourcing the code so that the community can contribute to it and enhance it with some awesome new features and fixes. The current release includes just a few improvements (see the README file on GitHub for more information). Hopefully, some of the changes introduced in Polaris v2 will be backported into Google Maps Android API v2…

Go to Polaris v2 GitHub page

Using Polaris v2 in your projects

Using Polaris v2 in your projects is quite simple. The API exposed by Polaris v2 is a super-set of what the original Google Maps Android API v2 exposes. As a result, you only need to switch all of the imports from the Google Maps Android API v2 (com.google.android.gms.maps.*) to Polaris v2 (com.cyrilmottier.polaris2.maps.*)

Finally you can start interacting with the underlying GoogleMap by calling getPolarisMap() (instead of getMap()) on your SupportMapFragment, MapFragment or MapView.

Conclusion

While the original project at the root of Polaris was more featureful, this release is the perfect way for developers to start adding some missing features to the original Google-provided mapping library. Today, Polaris v2 is just a wrapper around the Google Maps Android API v2 but could easily become a must-use library in the future. The project is just waiting for the community to help it grow.

1. Having a deprecated API doesn’t mean it is not working anymore for all existing applications. Google only decided to prevent people from generating new API keys. As a consequence, it is now impossible to create new applications using the Google Maps external library except if you are signing your application with a certificate you already have assigned a map API key to.

Building an Android project can be challenging at times. The Android SDK ships with a set of helpful ant scripts, but has its shortcomings. It mainly lacks a well-populated dependency infrastructure similar to what maven offers (ivy doesn’t count). Hence, the natural evolution of build process spawned the maven android plugin. The plugin allows you to infuse maven artifacts and perform the necessary build steps to package your app. Although maven has a great artifact repository, it has a pretty rigid set of configuration settings. The pom files tend to get verbose and interfering with the designated build process lacks flexibility.

The “New Build System”

Entering the “New Build System” based on Gradle. The new build system is supposed to become the official mechanism for building Android applications. The gradle-based build combines some of the strengths of ant and maven (flexible architecture with a lot of custom tweaking opportunities), whilst at the same time providing reasonable default configurations to keep the build scripts small. Maven dependencies can be consumed from maven central, while it is also easy to consume “local file” dependencies.

Okay, but how does the “New Build System” prevail in practice?

Using the Gradle Android Build

DISCLAIMER: We are only a few days away from Google IO 2013 so the points raised here might have already changed when you read this.

Basic build scripts can be really really small when you rely on the default folder structure for your project. Your basic gradle build script can look like this:

buildscript {
  repositories {
    mavenCentral()
  }
 
  dependencies {
    classpath 'com.android.tools.build:gradle:0.3'
  }
}
 
apply plugin: 'android'

In fact the buildscript{} element is only required to bootstrap the script itself. The actual content is the lonely apply plugin: 'android'. Running this script produces a fully runnable unsigned apk.

The basics are simple but what about dependencies? As I mentioned, you can easily add dependencies from maven central or a local file. In fact, the buildscript downloads its own android tasks from maven central.

repositories {
    mavenCentral()
}
 
dependencies {
    compile 'com.google.guava:guava:11.0.2'
    compile files ('libs/gcm.jar')
}

The compile directive is similar to mavens compile scope in that the dependency will be bundled into your packaged .apk.

Gradle also supports Android library projects. The “New Build System” compiles library projects into .aar packages, which can be consumed by the main project. The main advantage of the .aar format is its ability to handle dynamic Android resource ids. You will be able to ship an *.aar archive and consume it in your main project without having to create all of its ids during compile time of the main project.

Library projects have to be listed in a settings.gradle file and all projects taking part in the build can reference any other project listed in that file.

Where the gradle build has its real strength is in creating multiple versions of the same app. For example, a free and a paid version, or different versions for various cpu architectures. I won’t go into detail but you should read all about it here.

Shortcomings

Now that we have discussed some of the strengths of the gradle build system, lets discuss some of the pitfalls:

The gradle build is not yet able to deal with the most common dependency format for library projects: the maven apklib. Currently you can only consume maven artifacts that are packaged as jars. This rules out a lot of high profile dependencies such as the actionbarsherlock or the viewpagerindicator. If you want to depend on these resources you will have to keep a source reference in your project (or package them as an .aar).

The gradle build system offers good support for instrumentation tests you run on your device, but it is currently very hard to run standalone robolectric tests. The main problem is that robolectric does not understand the gradle dependencies so that it cannot gather sub-dependencies, and so on.

Support for the Android Development Tools (ADT) is currently non-existent although this is very likely to change with future releases. The ADT cannot deal with the default folder layout by gradle, nor can it deal with declared dependencies. Therefore, you have to maintain two build infrastructures: one for Eclipse (project.properties etc) and one for the gradle build.

Wrap Up

The “New Build System” build sounds awesome! As long as it can deliver on all its promises. At the moment, I can not recommend it for larger projects due to the lack of robolectric support and problems with maven dependencies.  I have discussed the issues raised here with +Xavier Ducrohet, the lead architect of the build system, and he assured me that most of the issues will be addressed. At the Droidcon Berlin I spoke to Hans Dockter, the CEO of Gradleware and co-architect of the “New Build System”, and once gradle becomes the driving engine for the ADT the entire toolchain should be covered. If the Android library ecosystem were to adapt gradle, it would have a very bright future.

A couple of days back, Samsung surprised the whole world by churning out the successor of Tab 2 that was destined to be released at IFA 2013. Anyway, we have the review device with us and we were lucky enough to run a few benchmarks on it to see how it compare benchmark wise to [...]

The post Galaxy Tab 3 7 Benchmark, Review, vs Tab 2, iPad Mini appeared first on Galaxy Tab Reviews, News, Updates.

After a few delays, the inaugural mission of the Orbital Sciences Antares mission successfully made it into orbit on April 21st. While the mission didn’t carry the actual spacecraft Antares is designed to lift (that’s currently slated for June), it didn’t go up there empty handed.

The Antares rocket safely delivered all three of NASA’s PhoneSats into their intended orbit, and according to amateur radio operators all over the world, the three micro-satellites are performing as expected.

NASA’s PhoneSat

Global Effort

As the PhoneSat satellites have rather limited transmission capability, NASA is relying on a global network of amateur (AKA ham) radio operators to keep an ear out for these tiny little craft.

By openly documenting the spacecraft’s packet protocols, listing the frequencies they will be transmitting on, and even displaying an animated map to show where each PhoneSat is in the sky, NASA has given the public everything they need to receive regular downlinks.

Once a radio operator has received one of these broadcasts, he or she can upload it to the PhoneSat.org site, where it will be cataloged. When enough data has been collected, NASA will (hopefully) be able to piece together information spanning the entire mission, including the sensor data and images the PhoneSats are constantly sending out.

Listen Up

Interested in trying your hand at receiving signals from these Android-powered spacecraft?

It’s not nearly as complex as you probably think, as there are now multiple low-cost USB radios which can be used to receive satellite transmissions. All you need is a decent antenna, and some patience.

Take a look at our guide on RTL-SDR for some ideas on how you can get started in the fascinating world of amateur radio for around $30 USD.

For some reason, Samsung did not activate full tablet UI on the Galaxy Tab 2 7.0. There is a way to enjoy full tablet UI by using Xposed installer and Xposed TabletUI Trigger. However, you need your Tab 2 7.0 to be rooted for it to work. 1. Download the Xposed Installer from here. 2. [...]

The post Tablet UI on Galaxy Tab 2 7.0 appeared first on Galaxy Tab Reviews, News, Updates.

Last month, we brought you a review of the MG, an Android powered handheld gaming system designed for casual games. The combination of vanilla Android and the MG’s custom parental controls made the device a compelling option for gamers young and old alike, and its comparatively low price combined with the vast Android software library offered an unbeatable value.

The team behind the MG had obviously done their homework and targeted the product to a very specific market which was otherwise being ignored. Rather than throwing out a half-realized device that didn’t resonate with any particular use case, the team engineered the hardware and software experience to their target audience to great effect.

Taylor Cavanah

To learn more about the focus and vision which made the device a reality, we got in touch with MG’s physicist turned meta-gamer Taylor Cavanah.

Creating the MG

The Powerbase: Taylor, thanks for taking the time to talk with us. Can you start by telling our readers a bit about yourself and your background?

Taylor: I’m a physicist and started my career in Nanotechnology at Zyvex.  After finding some success in developing the nanoprobing market for the semiconductor industry I decided to strike out on my own.  My buddies and I started our own software company – Locai – and a year ago we combined forces with the hardware and business guys from ACTScom to launch PlayMG.

The Powerbase: What exactly is your role at PlayMG? What are your day to day responsibilities like?

Taylor: My specific role involves game/app design, platformsoftware design, business development, innovation, and as is the case with all start ups – many more roles.  Day to day I was either talking with game houses, working with the hardware guys to design the user experience, writing the story behind our game within the gaming device app Origins, looking for interesting apps to work with, working with marketing to craft the messaging behind these features we were building, and testing devices in every possible way.

The Powerbase: PlayMG has no qualms about the fact it has targeted the MG to younger gamers. Why do you think the younger gamer is so important? What makes the MG a better option than, say, mom’s old smartphone?

Taylor: Every one has a slightly different opinion on this but for me the younger gamers make the most sense because they can’t have phones.  Whether their parents don’t want them or can’t afford the data plans, there are a lor of younger gamers who love apps but can’t get access to them.  The “hand me down” argument is definitely valid.  I can hand down my phone and just remove the plan and then they have a smart device.  That’s where our added benefits factor in to the equation.  You can’t get Family Collaboration, SpendSmart, or the Origins game in a hand me down.  And sometimes more importantly, you can’t get that “awe” moment when your son or daughter opens up your repackaged device from 2 years ago.

Android and the MG

The Powerbase: Its differences aside, the majority of the MG’s software is straight Android. Would it be safe to say that, if it wasn’t for the open nature of Android, the MG wouldn’t exist in its current form? Would have putting this same hardware out with a proprietary operating system have gotten you as far as Android has?

Taylor: There is no way we would exist without Android.  The barrier of entry previously was just too high.  We got a solid and awe inspiring product to market in 9 months.  Core to that was not having to build an entire OS.  Not just in terms of getting something to market but that greatly helped us focus our time and money where it mattered – on the added benefits like Family Collaboration and Origins.  This is what I love about open source – you get to make products with extremely well designed experiences where it matters.

The Powerbase: One of the biggest selling points early on was that the MG would be a vanilla Android device, meaning it would be as close to AOSP as possible. In the end the MG delivered on that promise, and is one of the few non-Nexus devices available running stock Android. Why was running stock Android so important for the MG?

Taylor: Part of that answer has to do with my previous answer – it’s just easier to not build stuff you don’t need.  I think everyone can point to some larger companies that have large engineering staffs that have to build stuff because those salaries are being spent no matter what.  Then you get a lot of customization away from stock.  But most of that is useless and provides no value to the customer experience.  A lot of engineers also like the job security that building all of this custom stuff gives them.  They will always be needed because only they know how this version of flavored Android operates.  For us it was exactly that overhead that we didn’t want.  If we build our own flavor of Android then every new app or platform we create down the road has to take that into account.  We had to keep our focus on what mattered for the end user.

The Powerbase: From a development perspective, stock Android is generally preferable to manufacturer modified builds, but what about the end user? It’s no secret that the most popular Android devices (such as Samsung’s Galaxy line) make use of manufacturer modifications to their interface and applications, so the public doesn’t seem to mind. Do you ever worry that shipping with stock Android rather than a build with more visual flair and streamlined functionality pleases the developers at the expense of the end users?

Taylor: I have never believed that popularity of a device has anything to do with how well it is designed or received by customers.  The large software guys have proven time and again that being big in a space and having a ton of money can make up for a lot of deficiencies.  I say this because I don’t believe customers buy the Galaxy line because of the manufacturer improvements – most customers have never seen stock Android so they don’t know any better.  My guess is the commercial bashing the iPhone (hilariously with the parents in line) did a lot more than the user experience.  From what I’ve seen all of the added modifications make little difference to the real end users (not us tech types who are too deep in the space).  We found you could do an amazing amount of things just using the widget system in Android to change the user experience – without huge teams to build and then manage modifications.

The Powerbase:  Some would say that shipping the device with vanilla Android only makes sense if it’s kept up to date with AOSP (such as the Nexus line), but the MG is still on 4.0.4. Why hold the MG back? Are there plans on updating to Jelly Bean (and beyond)?

Taylor: We will update to Jelly Bean.  But with such a low saturation of Jelly Bean and many apps still not upgraded for the experience it doesn’t make sense to expend the effort.  Again we’ve got to focus on that end user experience and the only people ever asking for Jelly Bean are analysts or the random parent who just saw some article that mentioned the new Jelly Bean thingy for Android.

Expanding Android Gaming

The Powerbase: One of the best features of the MG, at least for parents, is unquestionably the Family Collaboration System. While it currently sets the MG apart from the competition, would PlayMG consider bringing it to generic Android devices? Perhaps charging a monthly subscription fee when used on non-MG hardware?

Taylor: We are always weighing the pros and cons of releasing some of the proprietary apps to the Play Store.  Right now we only have to manage one device, we get to ignore fragmentation, and we have a competitive advantage.  I don’t see us releasing the apps until we are much more established.

The Powerbase: An advantage of putting out an Android based gaming system is, of course, that you aren’t responsible for developing or publishing games for it (unlike traditional game consoles). That said, are there plans to talk to developers about MG optimized games? Is that already happening?

Taylor: Nothing that I can talk about but we definitely have plans and some preliminary talks about using our PlayMG IP to create games.  Any game developers interested (especially if they want to do something outside of the normal bounds of gaming) should get in touch with us.

The Powerbase: You can’t talk about Android gaming anymore without mentioning the OUYA; while it’s aiming for a completely different market than the MG, are there any parallels you draw between them? Do you see families owning both devices in the future?

Taylor: Mine arrives in 3 weeks (if I had more time and money I would have gotten a developer version).  I would love to work with OUYA in the future and I do believe that console gaming and portable gaming will always be with us.  Where the hardware, software, and interfaces end up who knows but for now there are many opportunities that could be explored between the two companies.  For the next year though I’m guessing both of us will be too busy to pursue them.

Looking Ahead

The Powerbase: A common criticism of the MG is that it lacks physical controls. This was a design decision based on the intended userbase for the MG, but it’s also undeniable that there are hardcore gamers out there that would appreciate an MG-like device with physical input. Is this a challenge PlayMG might take up in the future? Perhaps a device like the Sony Xperia Play, but in a non-contract form like the MG?

Taylor: I don’t see that happening.  Our target user is not hardcore and in fact probably did not grow up with a game system that had controllers.  But at an even deeper philosophical level (get ready for the fan boy to come out) I think the portable gaming systems with controls aren’t just missing the mark but don’t really have a mark to hit.  Portable gaming is about the casual experience on the go or that little block of entertainment that you carry around in your pocket.  I have so many different serious game devices where I can have mind blowingly immersive experiences – but that’s not what you want in a portable gaming device.  At the end of the day we talked to a bunch of “gamers” in our demographic and they wanted a device they could put in their pocket versus a device that let them play games designed for pre-touch devices.

The Powerbase: If it’s not giving too much away, what can you say about the future of PlayMG and the MG itself? Anything current or future owners should be looking out for?

Taylor: We have some great plans for the Family Collaboration System – making it much more collaborative.  A lot of parents and even kids have asked for expanded features here.  I’m most excited about expanding the portable fun in the device.  The entire industry as a whole is barely scratching the surface of what you can do with portable gaming.  We have some very interesting things planned for making shared portable gaming experiences like no one has seen before.  Unfortunately I can’t say much more than that.

Thanks to Taylor and the entire PlayMG team for their assistance and professionalism while we worked on the original hardware review and this interview. We’re very interested in seeing where the future takes PlayMG, keep an eye out here on The Powerbase for future coverage of this unique company and its products.

Today we are proud to release Tabris 1.0. If you have not followed us so far you probably don’t know what Tabris is. Let me put it in one sentence: Tabris is the first Java-Toolkit for the cross-platform development of native mobile Apps. It enables you to write iOS and Android Apps completely in Java with a single code base. With this post, I want to sum up our journey till now and show you which features have made it into the 1.0 release.

Tabris sits on top of Eclipse RAP. RAP provides a UI Toolkit to write Web applications using Java. This UI Toolkit is based on Widgets, so you don’t have to mess around with HTML. To be able to display those widgets in a browser, RAP uses a protocol which is based on JSON. Within this protocol are messages that instruct the browser e.g. to display a button, or a tree, and so on. What Tabris does is to provide two alternative clients which are an iOS and an Android client. Those clients simply understand the RAP protocol messages and display widgets using the native counterparts.

On April 28th, 2010 we have previewed a version of the RAP protocol which basically marked the start of Tabris internally. Two months later (June 11th, 2010), we had the first working prototype which has used Apple’s iAd JavaScript framework for rendering. Since then we have worked on what is today released as Tabris. It includes two native clients and an extension of the server side RAP API. This extension, which is just another jar, is necessary because the RAP API is based on the Standard Widget Toolkit (SWT). SWT is limited when it is used on mobile devices. There are no APIs for Geolocation, Camera and other things a mobile App typically use.

The first time we made our mobile clients public was the start of our “developer preview” back in January 31st, 2012. At this time we concentrated on implementing a proper support for the SWT widgets. Since then, we have released 14 milestones. The last public milestone was tagged with 0.11.0. We think that this was the most important one for Tabris. It introduced a feature called the Tabris UI. Tabris UI is a higher level API for creating a frame for your mobile application. The native clients use native navigation concepts to display a Tabris UI-based application. On Android this is the ActionBar and on iOS these are the ViewControllers. So, since Tabris 0.11.0 it has been possible to write native applications using native Widgets combined with native navigation concepts.

In the last weeks we have concentrated on Bug fixing and API cleanup to ship a release we can be proud of. If you would like to try out Tabris yourself, just download the 30 day trial version. This trial has no functional limitations! To get started with this trial we have created some detailed getting started guides you can use. We have also created a bunch of screencasts that show some of the features Tabris provides. You can find the new & noteworthy articles so far below:

• Tabris 0.5.3
• Tabris 0.5.4
• Tabris 0.5.5
• Tabris 0.5.6
• Tabris 0.5.7
• Tabris 0.5.8
• Tabris 0.6.0
• Tabris 0.6.1
• Tabris 0.6.2
• Tabris 0.7.0
• Tabris 0.8.0
• Tabris 0.9.0
• Tabris 0.10.0
• Tabris 0.11.0

At this point I want to thank the community which has provided us with great feedback, feature requests and bug reports. I also want to thank the rest of the Tabris team: Jordi Böhme López, Johannes Eickhold, Moritz Post and Ivan Furnadjiev for doing a great job over the last year! And last but not least, many thanks to the Eclipse RAP team for their great support!

This should come as no surprise to most of you, but Samsung has the two most popular tablets according to two different analyses. The Galaxy Tab 2 (7.0 inches) is estimated to have 11.8% and 18.3% market share in the Android tablet realm. Next up is the Galaxy Tab 2 10.1 with between 8.3% and 14.4% market share.

Read Write published that the list on the right is significantly more accurate than the one on the left, so a Kindle Fire might has squeezed into second place. Still, the Galaxy Tab 2 line is immensely popular.

Also take note as to how many Samsung tablets are on that list. My math says that Samsung holds 54.2% of the Android tablet market.

Source: Read Write

With Native Union’s SWITCH Bluetooth wireless speaker, you’ll be able to share your favorite music with everyone in the room. It’s also a great way to amplify games and movies from Bluetooth-enabled devices, and it can be used as a professional conference call solution with its full duplex microphone.

Designed by professional sound engineers to ensure exceptional sound and optimal clarity throughout the frequency range, the SWITCH features three powerful speakers — including an active sub-woofer and has an enhanced bass-reflex system. Featuring an intuitive volume control the SWITCH also enables you to effortlessly alternate between music and calls for up to 14 hours at a time. The battery is so powerful, the SWITCH can also function as a power bank for your mobile devices.

The SWITCH can be used either vertically or horizontally, and it features a soft touch exterior that’s available in multiple colors. Check it out today, and get your party started.

public interface A {
    void a();

    static class AImpl implements A {

        @Override
        public void a() {
            // ...
       }
   }
}

public A getA() {
    return new AImpl();
}

Delivering state-of-the-art design, ease-of-use, and outstanding sound quality, Jabra’s newest corded and wireless stereo headphones are perfect for hard-wearing, everyday use and portability. The lineup includes the over-the-head Jabra Revo — available in corded and Wireless versions — and the small but tough in-ear Jabra Vox.

The Jabra Revo Wireless

Jabra Revo Corded and Wireless

Both the Jabra Revo Wireless (a 2013 red dot design award winner) and Jabra Revo corded headphones (the latter available in gray and white) are solidly constructed using an aluminium frame, steel hinges, and a shatter-proof headband for extreme flexibility. Both the corded and Wireless versions are super comfortable with a padded headband and plush, memory foam ear cups. They feature a foldable design for quick, compact storage and come with a detachable cord and USB charging for convenience.

Play or pause music, skip tracks, and take calls with ease by using in-line controls on the corded version instead of searching around for your phone. The Revo Wireless utilizes both Bluetooth and Near Field Communication (NFC) technologies to pair with your device, and its Turntable Touch Control allows you to easily play, skip, or pause your music while also managing calls.

The corded Jabra Vox

Jabra Vox

Size matters… especially when earphones so small command massive sound like Jabra Vox. Optimized for superior sound and performance with portable devices, the Jabra Vox really packs a punch. Get the perfect fit with specially designed ColorCore EarGels for enhanced comfort and deep sound. Vox’s earbuds are engineered to rest comfortably for extended use. The Vox also includes in-line controls for playing or pausing music as well as taking calls.

Dolby Digital Plus

With Jabra’s exclusive Sound App (available for iOS and Android devices), Dolby Digital Plus adds that extra depth and dimension to your music — extending bass performance and enhancing high frequencies so your music retains its clarity.

The Jabra Sound App automatically identifies your music files so it’s easy to get started. Simply download the App, and you’re ready to go. Use the App to create and browse through playlists, share music on Facebook or Twitter and adjust the graphic equalizer so you can play your tracks as you want to hear them.

Find the right headphone for your needs today, whether it be the corded in-ear Vox, corded over-the-head Revo (in gray and white), or the Revo Wireless for the ultimate in freedom.

Recently I had a specification for showing thumbnail images in a constant 4:3 aspect ratio regardless of the aspect ratio of whatever image would be displayed. I found a lot of references to manipulating and scaling the image, but not many for scaling the ImageView itself. I did find one good clue from Bob Lee in this Stackoverflow post, so I adapted it.

In a subclass of ImageView you can override onMeasure(), as below, to force a 4:3 or other aspect ratio on the instances. If you are making thumbnails, you’ll also want to scale the bitmaps so they “fit” per your specifications. The specs from my UI designer were pretty specialized so I won’t include the code I used for scaling.

@Override protected void onMeasure(int widthMeasureSpec,
   int heightMeasureSpec) {
//   let the default measuring occur, then force the desired aspect ratio 
//   on the view (not the drawable).
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int width = getMeasuredWidth();
//force a 4:3 aspect ratio   		   
int height = Math.round(width * .75f);
setMeasuredDimension(width, height);
}

Some of you may have noticed the maintenance page this weekend and the new face of this website. I’ve recently spent some time lately working on a complete redesign of my cyrilmottier.com domain. Here is a brief explanation of the motivations behind this redesign and a list of the main changes.

3 or 4 months ago I received an email from my host telling me they were dropping support of my old version of PHP (5.2). The version of Wordpress used for my android.cyrilmottier.com blog was so old it wasn’t supporting the PHP 5.4 and can’t even upgrade itself to a PHP 5.4 compliant version… Not being a server/backend guy, I decided to go for a complete redesign of both the guts and the look of cyrilmottier.com.

No more PHP or MySQL

The new version of the website is now using Octopress. Put simply, Octopress is a static website generator. Some of the main advantages of Otopress over Wordpress is it requires no SQL and no PHP, is responsive by default, deals perfectly with code snippets and relieve me from the pain of updating stuff I don’t know well. The only required piece of software Octopress needs is … Apache.

Bringing simplicity

The cyrilmottier.com domain was previously redirecting to a landing page made of tons of redirections to subdomains. Whilst it keeps clear sections in your website, it is hard to maintain and require time I don’t have (nor don’t want to spend on). As a result, I decided to go for something way more simple:

android.cyrilmottier.com is now cyrilmottier.com

In the process, I removed several subdomains and redirections I considered outdated and useless :

• My professional website
• A prehistoric web page of my TI calculators apps
• A old blog about my experience as an Erasmus student in Helsinki, Finland
• A file manager I never ever used in 5 years

Holo-like theme

Aside from removing a bunch of subdomains, I also created a theme from scratch. Once again, the idea behing the ‘Carrot’ theme (don’t ask me why I decided to name it that way) is to make things simple, remove all distractful and useless info just like the Android Holo style does. I really think I managed to focus on the content by getting rid or minimalizing of all secondary information.

As a mobile UI/UX engineer and designer, I wanted to finally have a website that looked like what I would have done if my website was an Android app. You can now notice the new website is layout and density¹ responsive. As a result, it renders like magic on phones as well as tablets and desktop

Do not hesitate to delegate

Static websites don’t let you create dynamic algorithms… After all that’s what “static” means :). In order to keep features such as comments or search I used a plain old design pattern in computer science: delegation. Starting from now, comments are managed by Disqus², and search is done by the best search-engine in the world: Google.

Miscellaneous

Meaningless URLs are now over. When creating android.cyrilmottier.com I wanted to have short URLs to blog posts. The only purpose of this was to avoid the use of URL shorteners in social networks such as Twitter. However, using short URLs is far from being a great search engine optimization (SEO). Now that Twitter automatically shorten URLs, I’ve decided to switch to a more standard URL model:

http://cyrilmottier.com/<year>/<month>/<day>/<post-slug>.html

The previous version of android.cyrilmottier.com was great for accessing new content but it wasn’t easy to browse the entire content of the blog. The new version now includes an ”Archives” page you can use to easily browse old posts.

Conclusion

I have spent quite a lot of time redesigning this domain but it was worth it. I learned tons of new stuff and I loved it. From a user point of view, everything should work fine seamlessly. However, as I said, I’m not a server administrator nor a backend guy so please contact me if you think something is wrong.

One of the redirection that scares me the most is the RSS feed (R.I.P. Google Reader …). The URL (from http://android.cyrilmottier.com/?feed=rss2 to http://cyrilmottier.com/atom.xml) as well as the format (from RSS2 to ATOM) has changed so please make sure you RSS reader now points to http://cyrilmottier.com/atom.xml.

1. I’m only talking about the theme. Indeed, images from posts are not density-responsive for one single reason: Octopress nor HTML correctly handles it.

2. Disqus comments are not activated nor migrated for now but I plan to do it as soon as possible.

Your should not use static for defining fields for Views in your Android application.

Then creating a View, the LayoutInflater (used in setContentView(R.layout.ID)) uses the current Context (of the Activity) and pass it to the inflated Views. A reference to the given Context is always kept by the View class and can be retrieved via the getContext() method.

As a consequence, keeping a static reference on a View means that your Activity keeps a reference on your View which keeps a reference on the activity instance. This is what leads to the leak.

Thanks to Cyril Mottier for explaining that in G+.

This week’s wallpaper is called Top of the Rock. It was taken by benwall.

Download Links

Original Galaxy Tab: Click here to download
Galaxy Tab 10.1/8.9: Click here to download

How to add a wallpaper for noobs.

• Click the download link above on your Galaxy Tab
• Longpress on the wallpaper image
• Click set as wallpaper

If you want to know the current Android maintainer you can use the following link:

Android framework maintainer

Thanks to Arvid Gerstmann for pointing me to that URL on Google+.

Since Posterous will be shutting down its services in April, I have to pack my things and leave. Where to? Well why not move to GitHub, where I spend too much time already anyway. Google and GitHub now finally own all my data.

So from here on it's good bye Posterous, hello Octopress:

http://mttkay.github.com

I think I've spent more time updating links this month than doing anything productive. Spring clean up galore. I promise that unless GitHub dies, that link will not change.

See you around.

Permalink | Leave a comment  »

When your app has multiple text entry fields that must be checked for validity before the next action happens, it can be important to know that the user dismissed the soft keyboard via the back button. Typically you would want to listen for key and/or touch events from the fields so as to run your validation routine. However, there is not an easy way to get the information about dismissal of the keyboard.

There was a helpful answer posted to Stackoverflow by  Steelight who offered an override of the onKeyPreIme method that you add to your new instance of the EditText class. This is fine if you can do e = new EditText(inflater.getContext()) but not so good if you have to get your EditText instances via e = (EditText) findViewById().

Try creating a subclass of EditText and overriding its onKeyPreIme method. Then you can use this subclass anywhere, especially if you put it in a library project.  If you make the onKeyPreIme method send a key event and your instances of this subclass listen for key events, you can detect that the keyboard was dismissed and do whatever you’d do when any key event is received.

/**
 * This class overrides the onKeyPreIme method to dispatch a key event if the
 * KeyEvent passed to onKeyPreIme has a key code of KeyEvent.KEYCODE_BACK.
 * This allows key event listeners to detect that the soft keyboard was
 * dismissed.
 *
 */
public class ExtendedEditText extends EditText {

	public ExtendedEditText(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);

	}

	public ExtendedEditText(Context context, AttributeSet attrs) {
		super(context, attrs);

	}

	public ExtendedEditText(Context context) {
		super(context);

	}

	@Override
	public boolean onKeyPreIme(int keyCode, KeyEvent event) {
		if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
			dispatchKeyEvent(event);
			return false;
		}
		return super.onKeyPreIme(keyCode, event);
	}

}

When uploading multimedia or binary files to your Amazon Mobile App Distribution Portal account, files larger than 100 MB must be uploaded using FTP. To upload your larger assets using FTP, simply follow the below instructions:

On the Images & Multimedia or Binary File(s) tab in your app details, click on the FTP instructions and naming convention link to obtain the app-specific naming conventions you will need to upload via FTP.

FTP Upload Steps

 1.  Select the app whose file(s) you will be uploading using the dropdown

2.  Use the generated name list to rename any assets over 100 MB to the specific file name provided—this file name is how Amazon will know what app and asset field to apply the file

3.  Using the FTP client of your choice, login and upload your renamed files using the specified FTP server and username—if needed, reset your password to have a new one sent to you

4.  You’re almost done! Simply review and submit your app once your files appear uploaded

Allow up to 20 minutes for an e-mail confirmation that your assets are processed and available. You will also receive an e-mail if the uploaded asset is invalid or misnamed. E-mails will be sent to the e-mail address you have provided us in your Distribution Portal profile. Once the asset has been uploaded, finish any remaining steps and review your content one last time. After you have satisfied all the asset requirements, you will be able to submit your app to have it reviewed for inclusion in the store.

For more information about the FTP naming convention, click "Read More".

More about the FTP Naming Convention

Every app has a unique application ID (appId below) that is a required part of the filename when you upload via FTP. Including the package name after the application ID is optional—add the package name only if it helps you organize your files.

Small icon (114 x 114 pixels):  appId-AD-ICON.png  or  appId-package.name-AD-ICON.png

EXAMPLE:  M0A2KAXJX4CATH-AD-ICON.png or M0A2KAXJX4CATH-com.example.mobile.app-AD-ICON.png

Large icon (512 x 512 pixels):  appId-AD-THUMB.png  or  appId-package.name-AD-THUMB.png

EXAMPLE: M0A2KAXJX4CATH-AD-THUMB.png OR M0A2KAXJX4CATH-com.example.mobile.app-AD-THUMB.png

Screenshots (1024 x 600px or 800 x 480 pixels): appId-AD-SHOTXX.png or appId-package.name-AD-SHOTXX.png where XX is an optional numerical index of the image

EXAMPLE: M0A2KAXJX4CATH-AD-SHOT.png, M0A2KAXJX4CATH-com.example.mobile.app-AD-SHOT.png, M0A2KAXJX4CATH-com.example.mobile.app-AD-SHOT1.png, M0A2KAXJX4CATH-com.example.mobile.app-AD-SHOT05.png

Promotional image (1024 x 500 pixels, landscape only): appId-AD-PROMO.png or appId-package.name-AD-PROMO.png

EXAMPLE: M0A2KAXJX4CATH-AD-PROMO.png or M0A2KAXJX4CATH-com.example.mobile.app-AD-PROMO.png

Video(s): appId-AD-VIDEOXX.png or appId-package.name-AD-VIDEOXX.avi where XX is an optional numerical index of the video

EXAMPLE: M0A2KAXJX4CATH-com.example.mobile.app-AD-VIDEO.avi, M0A2KAXJX4CATH-com.example.mobile.app-AD-VIDEO1.avi, M0A2KAXJX4CATH-com.example.mobile.app-AD-VIDEO05.avi

Binary file/APK:

Signed by Amazon (recommended)

With DRM: appId-<binary alias>.apk  or  appId-package.name-<binary alias>.apk

EXAMPLE: M0A2KAXJX4CATH-my_alias.apk or M0A2KAXJX4CATH-com.example.mobile.app-my_alias.apk

Without DRM: appId-<binary alias>-nodrm.apk  or  appId-package.name-<binary alias>-nodrm.apk appId-<binary alias>-nodrm.apk  or  appId-package.name-<binary alias>-nodrm.apk

EXAMPLE: M0A2KAXJX4CATH-my_alias-nodrm.apk or M0A2KAXJX4CATH-com.example.mobile.app-my_alias-nodrm.apk

Signed by you

Unsigned binary with DRM: appId-<binary alias>-precert.apk or appId-package.name-<binary alias>-precert.apk

EXAMPLE: M0A2KAXJX4CATH-my_alias-precert.apk or M0A2KAXJX4CATH-com.example.mobile.app-my_alias-precert.apk

Unsigned binary without DRM: appId-<binary alias>-precert-nodrm.apk or appId-package.name-<binary alias>-precert-nodrm.apk

EXAMPLE: M0A2KAXJX4CATH-my_alias-precert-nodrm.apk  or  M0A2KAXJX4CATH-com.example.mobile.app-my_alias-precert-nodrm.apk

Signed binary: appId-<binary alias>-mycert.apk or appId-package.name-<binary alias>-mycert.apk

EXAMPLE: M0A2KAXJX4CATH-my_alias-signed.apk

As part of our series of “how to” blog posts, we’d like to provide updated instructions on how to update your app and app’s metadata using the Amazon Mobile App Distribution Portal. Whether you’re submitting new screenshots, an updated description, or a totally new version of your app, these instructions will guide you through the process of getting the updates to your users.

Updating Metadata (screenshots, descriptions, etc.)

1. Go to the My Apps section in the Distribution Portal.
2. Click on the current live version of your app.
3. Click the “Description” or “Images & Multimedia” tab, depending on what you would like to update.
4. Click the “Edit” button (in the bottom right corner).
5. To remove an existing image, tap the “X” in the top right corner. To add a new image, click the “Upload Image” image.
6. Click the green “Save” button in the bottom right corner.
7. Click the “Submit App” button.

Updating to a New Version

1. Go to the My Apps section in the Mobile App Distribution Portal.
2. Hover your pointer over the app for which you are creating an updated version, and then choose “Add Upcoming Version” from the menu on the right.
3. If no metadata updates are required with the new version, tap the “Binary File” tab, then tap the “Upload Binary” image.
4. Review and certify your app for Export Compliance.
5. Click “Release Notes”, and then click “Edit”. Add in release notes. Click “Save”.
6. Click the “Submit App” button. 

Here's a little tool I wrote for handling 9patch images called 9tool. If you work with (a lot) of nine patch files in Android, you might find it handy too.

• My workflow currently is something like this:
• Get the xhdpi asset and make it a nine patch using draw9patch
• Get the other states for the asset and do a 9tool copy on it to copy the nine patch area to those assets, then load those in draw9patch for some touch ups.
• Now get the other assets for other dpis. 9tool copy the patches I made from the xhdpi assets to the other dpi variants, touch up using draw9patch again.

This saves me a bunch of manual drawing in draw9patch and makes me a happy camper!

The tool is hosted on bitbucket here: https://bitbucket.org/hvisser/9tool

Permalink | Leave a comment  »

Being sloppy when it comes to managing your application's resource IDs can lead to subtle bugs that are difficult to find and debug. Imagine a scenario where foo_activity.xml holds the layout definition for FooActivity, and you define three different variants for different screen configurations:

res/layout/foo_activity.xml
res/layout-land/foo_activity.xml
res/layout-sw600dp/foo_activity.xml

Now, with some certainty these three layouts will share the same views, with the same IDs, just slightly differently styled or arranged. Let's furthermore assume in all three layouts, we have a TextView:

https://gist.github.com/4682037

FooActivity will of course retrieve a reference to this TextView via findViewById:

https://gist.github.com/4682053

Now what happens if in the main layout file (layout/foo_activity) you change the view's ID? You may be surprised to hear that your application will still compile. That's because the old view ID, my_text, still exists in R.java, since while now gone from layout/foo_activity.xml, it's still (re)created using the @+id notation in the other two layouts, thus continuing to exist in the ID pool. Whenever these layouts are loaded and you reference the new ID from FooActivity, then of course your application will crash.

The problem here stems from violating the DRY principle: we're carelessly repeating the code which creates a resource ID, when ideally, it should only ever be found in one, and only one part of the application. To recall what @+id does, it's an idempotent "create this ID" action. In other words, if that ID has not been defined yet, it will get defined, otherwise it will be used. So it's safe to use this notation multiple times with the same ID, which may be the reason why people overuse it: it looks like a safe bet, when it's actually not.

There are three approaches I have tried to deal with this issue:

1 - Pulling view IDs into styles

When redefining views multiple times in different layouts, one approach could be to extract the respective view IDs into a style, then apply the single shared style to all three variants of the view:

https://gist.github.com/4682862

https://gist.github.com/4683025

While I first favored this, there are several problems with this approach: first, it reduces the visibility of IDs, which can be confusing when dealing with views in RelativeLayout, where you reference views using IDs. Moreover, IntelliJ IDEA at least will get terribly confused and issue an error, since it doesn't resolve styles to inspect the correctness of a layout file (it'll assume the view is missing the ID attribute.) Lastly, and this is purely a style question, one could argue that styles should be concerned with only visual appearance, not structural attributes like IDs.

2 - Pulling view IDs into ids.xml

Another option is to pull the shared view IDs into a global resource file, e.g. in res/ids.xml:

https://gist.github.com/4682090

This will turn the respective view IDs into first class resources themselves, and by extension make them reachable via R.id and in all layout files. Here, too, no @+-notation is required in any layout files anymore. You would define shared IDs in one, and only one location.

The problems with this approach are similar to 1, but it clears up with the stylistic problem of defining IDs in a style sheet.

3 - How We Do It (TM)

We ended up taking a third route, which is one of convention. We've agreed on establishing a rule which says that it's fine to use @+id in layouts files, but only use it in the default layout file, i.e. the one located in res/layout. Whenever a layout is overloaded using different configuations, then even for the same views, @id should be used. That way we ensure that there is only a single location where an ID actually gets defined, without taking it completely out of context when working with layout XML. Moreover, changing the view's ID will lead to compilation errors, since all overloaded variants now reference a non-existing ID.

I'd be interested to hear how everyone else deals with this. 

Permalink | Leave a comment  »

I've been reading "The Millionaire Next Door" and have so far found it to be a pleasant book with a good message: don't waste your money on silly things and appearance (fancy suits, fancy cars, expensive boats, etc...), save what you do earn consistently and constantly, invest wisely, and so on.   Wikipedia has a good summary:

http://en.wikipedia.org/wiki/The_Millionaire_Next_Door

One of the things I like about it is that it focuses on "ordinary" wealthy people, those with a million or more in the bank, but not the Warren Buffets or Bill Gates types that are extreme statistical outliers.  There are plenty of people in the US who have done well by themselves by slowly but surely putting together enough money to be financially independent, without, however, being in the spotlight.   As the book says, these are the kind of people who maybe own a local chain of businesses doing something fairly ordinary, but doing it well enough to succeed.  They may very well not live in a fancy house, nor drive an expensive car, or otherwise outwardly draw much attention to themselves.

The world of software does not revolve around "dressing for success" (you noticed?), but we do tend to focus on the "big winners".  Gates, Jobs, Zuckerberg, Larry & Sergey, Larry Ellison, and so on are the stars of the show.  Of course, the economics of software being what they are, instances of winner-take-all markets with one big fish and a lot of also-rans are not uncommon.   However, that is not the only story, and I think it'd be interesting to know more about those in our industry who have accumulated significant wealth, yet are not the guys with more money than they could possibly ever spend on things that aren't, say, country-sized chunks of real-estate.

I'm guessing they'd fall into these categories:

• Highly paid workers who have consistently saved over the years.  There are examples in the aforementioned book about people with relatively low salaries who happened to be very frugal and invest well (and have had some luck in their investments too).  These people would probably tend to be older, as it takes a while to save up that kind of money, and since this industry is so young with so much turnover, I would not think there would be a lot of people out there like this, but who knows, maybe there are a bunch of IBMers with this kind of story.
• Those who got in on the right IPO, like Google or Facebook or something like that.  These events not only generate billions for those at the top of the heap, but for the right person at the right place at the right time, can mean significant wealth even without being in the upper echelons of the company.  My suspicion is that this kind of IPO, where everyone cashes out, is not common enough to have a lot of people in this category, but who knows, maybe it adds up over the years.
• Those who own or started software firms that do something that's not very visible, but nonetheless dominates some particular niche.  This is where I'd guess most of them would be, but I certainly have no data or even anecdotes to back this up.

It'd be very interesting to gather some actual data on this, although I'm not in a position to do so myself - I wouldn't even really know where to start. 

As I age, I think the third category has begun to seem appealing in many ways - I'm simply not cut out for the Big Company life, and I'm not interested in living in Silicon Valley and going "all in" on the latest startup - I already did that, and while it was fun and I don't regret it, it's not the kind of thing I'd want to do now that I'm married and have kids.   Incidentally, this more relaxed, under the radar approach is exactly what is expoused in one of my favorite books of the past few years, Start Small, Stay Small.

Edit : I finished reading the book and reviewed it here: http://davids-book-reviews.blogspot.com/

Today Canonical announced the mobile version of Ubuntu. For me as a Linux fan this is very exciting news, however, the developer in me screams: “Not another phone I need to target when writing mobile apps”. I’m surely not the only one thinking that.

Currently the major smartphone OSes on the market are Apple iOS, Google Android (and Microsoft Windows Phone). Upcoming OSes that I know of and follow are: Mozilla’s Firefox OS, Jolla’s Sailfish, Blackberry’s BB10, Samsung’s Tizen and Canonical’s Ubuntu. Some of those will be released this year, other in the following years. Some might not be released at all and new ones will also try to enter the market.

The current generation of devices mostly have a OS specific user experience (with an exception of Android where manufacturers can somewhat customise the experience). The clear trend is that device manufacturers and operators want to differentiate themselves with different user experiences and we (as consumers) also want to have a unique device that separates us from our friends, which fits with our personalities – meaning there is demand and room for different operating systems.

If a new device is to succeed it has to have quite a large repository of apps that the user can use. That can be a taunting task for the newcomers as getting developers to make an app for their device is next to impossible due to the huge costs associated with it. In most cases that process involves rewriting the application from scratch in a different language.

Here is a list of the official languages and native (UI) frameworks for each of the platforms:

• Android – Java w/ Android framework
• iOS – objC w/ Cocoa
• Windows Phone – C# w/ Silverlight
• Sailfish – C++ w/ QML
• Firefox OS – JavaScript w/ HTML5
• BB10 – C++ w/ QML
• Tizen – C w/ Enlightenment Foundation Libraries
• Ubuntu – C++ w/ QML

As anyone who has been involved in the app developing process knows, it’s a major headache developing two mostly identical apps, but it’s more or less manageable. Developing the app for even more platforms would be infeasible (especially financially).

We need tools, which would enable us to stop writing the same code over and over again for multiple platforms. There are various technologies available which do just that and can be used to create 3rd party apps, the most popular of which is the over-hyped HTML5. Others include Flash (for iOS, Android), .NET with Xamarin’s Mono products (for Android, iOS), various JavaScript based abstraction layers (PhoneGap, Titanium, etc) and the list goes on.

Many see HTML5 as the silver bullet here, but I tend to disagree for a couple of reasons. First the bar for performance was set really high by Apple when they released iOS and currently HTML5 cannot get anywhere near it. It is also quite difficult to get a single sane way of integrating with the device user experience due to the fragmented nature of HTML and browser technologies.

Flash based apps do run fine on iOS and Android, but they lack integration with the look and feel of the underlying device. Meaning the technology is only useful for games, where the user doesn’t expect them to integrate well with the system. There is also a problem of being locked into the platform more than with other technologies – when Adobe decides to discontinue their Flash products (or export to iOS/Android feature) that’s that.

The Xamarin team has brought the powerful C# language and .NET framework to both iOS and Android platforms. They have created bindings for almost 100% of the platform provided APIs, so the applications written using their technologies are as good as the ones written with the official platform frameworks. This means that when targeting multiple platforms (Andorid, iOS or Windows Phone) most of the code, which doesn’t deal with the UI directly, can be reused – resulting in fewer bugs, faster development time and decreased costs while still providing the user with a native performance and look-n-feel they’ve grown accustomed to. And because it’s all based on the open-source Mono project it is all true and tested, it’s fast and stable – even Unity, the powerful gaming engine, uses Mono as it’s internal game logic engine.

The last technology, which promises extensive code reuse, native performance and device specific UX is Digia’s Qt Quick (QML). Most of the new upcoming mobile OS’es use this technology and Digia is committed to enabling the use of this technology on iOS, Android and even Windows 8 devices. The power of Qt Quick is that it separates app code and UI very well, enabling designers to quickly create and experiment with UIs for different form factors and devices. The moment it is available on more than one smartphone platform, this technology will become a serious contender when developing apps for more than one platform, which is one of the reasons why most of the upcoming OSes are using it for their native apps.

And now for some predictions for 2013.

Instead of having to write and maintain several versions for the app in objC, Java and .NET companies and developers will be looking for technologies like .NET/Mono and QML to write performance critical apps and JS/HTML5 to write not-so performance critical apps. Reusing code enables more innovation on the UI side for multiple platforms.

This means that when currently objC/iOS and Java/Android developers are very valuable to companies creating mobile apps, their value will decrease towards the end of the year and .NET/iOS+Android+WP and C++/QML developers will become a sought-after employee in 2014.

There will be many more smartphones which aren’t iOS or Android devices and which will look and feel awesome, they will have access to most Android apps in addition to apps optimised for those devices. The hardware manufacturers, most of whom currently have almost no way to differentiate their offerings, can regain market share and release cool products that the consumers will want to buy. (Except Nokia. Sorry, but you dance to Microsoft’s slow and steady beat now. Maybe next year. Probably 2015 though.)

This also means that the user experience will range vastly from device to device. Giving room for experimentation and much more choice. Apps will be available everywhere and they will fit in and be of better quality. The overall application store concept will transcend platforms and a competition of who can provide the best analytical and developer tooling will start.

And now, lets wait and see what the next 12 months brings us; whatever it is, it won’t be boring!

I recently discovered MyColorScreen where Android users publish their beautiful home screen setups. I am impressed by the work and care that people put in customizing their home screen and I am also proud to see this because it’s exactly what we intended when we decided users could replace the default Launcher with their own.

Since some of you asked to see my own setup, here it is. It’s basic and boring but very efficient for me.

We are pleased to announce the launch of a new Android application that may appeal to everyone who uses their phone while driving.

InDrive is a GPS-enabled application that combines the standard car home functionality with a trip computer and Poweramp support. The app makes it very easy to launch your favorite applications, directly dial numbers, view your trip information and control music playback*. It will auto launch when placed in a compatible car dock. If you don’t have a physical car dock, InDrive provides an option to force the phone into car mode, in which it will override the Home button.

* The music screen is designed to work in conjunction with Poweramp. Without Poweramp installed, you will only be able to do very basic controls such as switching to the next song in the default Android music player. Support for other media players is not guaranteed.

Please download the app from Google Play and tell us what you think. Your feedback is much appreciated.

Related posts:

1. TAT Home: 3D home screen
2. Nexus One desktop dock now available
3. Video: Flash 10.1 and a new home screen

Simple and clean widget designed to be a primary lockscreen widget. It shows current date and time together with events from your Google calendar. Swipe down to expand the widget to the entire lockscreen.

• Resizable and scrollable.
• Shows number of days/minutes to event.
• Tap on time to launch Clock app.
• Tap on date to open Google Calendar.

To add to the lockscreen:

1. Swipe lockscreen to the left until you see a big [+] icon.
2. Tap on the icon and select ‘Neat Calendar’.
3. Tap and hold on the widget and move it to the left of the camera screen.

To add to the home screen:

1. Open widgets list in the app drawer.
2. Tap and hold to place widget on the desktop.

Related posts:

1. Redial widget for Droid/Nexus
2. TAT Home: 3D home screen
3. Adobe Flash Player 10.1 on Droid X

• Availability of memory on mobile devices is limited.
• Availability of memory for a background app is even more limited.
• The user can pick a custom image, including very (I mean, very!) large images. And they need to be blurred as well (being an expensive operation, that's not something you'd like to do for big images on a mobile device).
• For realtime sharp to blurry images and the other way around, multiple images have to be saved, but the required amount of memory is usually not available.
• Earlier versions of Android did not quickly release bitmap memory (usually later on, sometimes not at all), making things even harder.
• Repainting of the wallpaper. Repainting multiple background bitmaps and moving elements is slow!

Yesterday the DroidconNL conference started with a keynote from greetz.nl called "Pushing Development Boundries". After some introductory talk from their marketing manager, this slide appeared on screen:

Sorry, but now you lost all credibility... #droidconNL twitter.com/botteaap/statu…

— Hugo Visser (@botteaap) November 22, 2012

I realise that might have sounded a bit harsh, so let me explain and give you some background. The last year I've been talking about "Embracing Fragmentation" at mdevcon, Mobile Down South and Apps World. The talk is about the challenges and opportunities developing and designing for the Android platform and showing what mechanisms are there to make it easy to deal with the "problem" of fragmentation, which honestly in my opinion as a professional Android developer, isn't as huge as some people would like you to believe.

To me "hell" in the context of software implies something that is hard, complex, unpredictable, fragile and whatnot. Resolution and DPI on Android do not fall in this category for me. If you qualify these things as "hell" and you're a professional Android developer, I think you need to read the rest of this post.

What's this DPI thing anyway?

DPI is short for dots per inch, also known as pixels per inch or PPI. On iOS Apple calls things with a high PPI count "retina" to indicate that you can't see the actual pixels on a screen since they are so close together that your eyes, or your retina, can't see the individual pixels. In a way DPI tell you about the quality of a screen. Generally, when comparing screens of the same size, higher is better.

Now what's the deal with resolution and DPI? Let's say you have a 4 inch screen and a resolution of 1200x800 pixels. At the same time imagine a 10 inch tablet screen at 1200x800 pixels. Which screen would have the highest DPI? The 4 inch screen, since it literally packs more pixels / dots per inch. Get it? When designing a user interface this is important, for two reasons:

1. You want your stuff make look good on any screen.
2. You want your stuff have the same size on any screen.

How do we generally measure things on screens? Pixels. This works fine when all screens have the same DPI. Let's say a screen has 100 dots per inch. That would mean that a line which is 100 pixels wide, would measure 1 inch exactly. Simple right? Now what happens if you draw that same line on a large screen, with the same resolution? There are less dots per inch, for example 50, so all of a sudden your 100 pixel line is now 2 inches wide. Not good!

On Android (and iOS for that matter) you don't deal with pixels as the unit of measuring things. You deal with density independent pixels, or dips for short, or dp for even shorter. On iOS you'd call them points by the way. What measuring in dips gives you is a consistent unit that takes into account the DPI, which becomes essentially a scaling factor. Let's say we'd call 50 dpi our "baseline" dpi at which 50 dips is exactly 1 inch. To make it show the same size on a 100 dpi device, we would take the scaling factor (twice the amount of pixels per inch) and draw it at 100 pixels, which would give us the same sized line. Why? Because 100 is twice 50, so our scaling factor is 2 and because 100 pixels at 100 dots per inch would be exactly 1 inch again. Confusing? Maybe, but the thing to remember is: you don't deal with pixels. You tell the Android how large a thing should be in dips and Android will take into account the appropriate scaling factor, figure out the right amount of pixels and will make sure the thing you are drawing to the screen is the same size no matter what screen your app is running on. Same for iOS: you tell the OS how large the thing you are drawing to the screen is in points, the OS figures out how many pixels that would be for the screen (either the same amount or twice the amount for retina screens) and it will look the same size, no matter if you are running on a retina screen or a non-retina screen.

So that leaves us at DPI hell. I guess what the speaker was referring to is how to make your stuff look good on any screen. First of all, it's good to know that Android currently has 5 DPI "buckets" that are relevant to developers. In order of lowest to highest DPI they are called ldpi, mdpi, hdpi, xhdpi and xxhdpi. As a contrast, iOS has two buckets: either non-retina or retina.

Like I said there's a scaling involved when an app runs on various screens. Scaling stuff you draw yourself at runtime is usually not the issue. You are rendering that stuff when the app runs so things will always look good. But what if you include an image and that image should be scaled up or down to make it the proper size for the given dips and DPI?

In that case you have two options:

1. You supply the image at a particular DPI and let Android deal with the scaling from that bucket to other buckets at runtime
2. You supply a scaled version for one or more DPI buckets

One strategy could be to only supply the assets for the xhdpi bucket and let Android take care of the scaling. Depending on your assets and the version of Android you are targetting this might work fine. Usually though you need some tighter control over how images are scaled. A common strategy would be to supply assets for the mdpi, hdpi and xhdpi bucket and aditionally a launcher icon for the xxhdpi bucket. Since ldpi devices are rare, the Android platform would take care of scaling to ldpi by conveniently scaling down the hdpi asset by a factor of two. Likewise assets for the tvdpi bucket (hey! you said there we're only 5 buckets! - I lied) should generally look fine when scaled by Android.

So you might be thinking: "wow, duplicating my assets for 3 different buckets AND creating 4 launcher icons seems like a lot of work". Yes, it is. But I most certainly wouldn't call it hell. Besides there are some great tools which help you to reduce the amount of work you need to do and Android has more mechanisms to reduce the number of bitmap assets in your project anyway.

One question remains: if it's not hell, how should you approach this then? Here's something that generally works when designing and scaling assets if you know the size in dips:

1. Design your asset doubling the size in dips. If your image is 100x200 dips then in pixels you design it at 200x400 pixels. This is your xhdpi asset. This works because at xhdpi one dip is exactly 2 pixels, meaning the scaling factor is 2. At mdpi one dip is one pixel which is equally handy.
2. Scale this asset down by 75%. This is your hdpi asset.
3. Scale the xhdpi asset down to 50%. This is your mdpi asset.
4. Put the assets in the correct resources folder within your project: drawable-xhdpi for xhdpi, drawable-hdpi for hdpi, drawable-mdpi for (yes!) mdpi.

I recommend starting from the highest DPI you need to the lowest, since scaling down from a higher resolution usually gives better results than scaling up from a lower resolution. I also recommend that for launcher icons, you use the excellent Android Asset Studio combined with an icon in svg format which will spit out the launcher icons in all DPI variations without even bothering scaling it yourself in your favorite asset creation tool.

Phew, that was a lot of text, just to explain it's not hell, but seriously: if you are an Android developer you should know the rules to play by. If you know them, then making your apps look great isn't hard. There's a lot of information on the subject at d.android.com, for example on supporting multiple screens, which I encourage you to read.

I hope you found this post useful, please leave any feedback in the comments, Google Plus or tweet at me. Thanks!

Permalink | Leave a comment  »

I’ve had lots of people tell me they enjoy Gem Miner 2, particularly the expeditions, but that they miss the old style freeplay. Well, good news, because in the new update you can now play the old Gem Miner: Dig Deeper freeplay mode, but with the new graphics and sounds from Gem Miner 2!

Note: to play this mode, you need to have purchased both “Gem Miner:Dig Deeper” and “Gem Miner 2″ and have them both installed on one device.

On starting freeplay mode in Gem Miner 2, you will now be presented with an option to play “Classic Freeplay” which is an identical version to Gem Miner: Dig Deeper, but using the Gem Miner 2 graphics.

Through a friend on Twitter who sent me a link of a iOS app using lmgtfy I wouldn’t have known this app existed!
This application will generate links to Let Me Google That For You (www.lmgtfy.com).
You can copy them to your clipboard, you can copy a short link (bit.ly) link to your clipboard or share them on twitter, facebook, email, messages and many more.
The unofficial Let Me Google That For You app (lmgtfy).

NEW: Change in menu -> LMGTFY options the language or Google viagra no prescription application for the results.
Just fill out the keywords in the searchbox and press one off the buttons.
Add your own Bit.Ly key: Menu -> Change Bitly settings.
This application is not developed, nor supported, nor affiliated with www.lmgtfy.com. It only generates links which direct to www.lmgtfy.com.

So easy to use and works so smoothly

If you haven’t yet heard of Ingress by Google then you have either been switched off from the social media world or don’t move in geeky enough circles (no G+ pun intended).

Enlightened vs Resistance is a mastermind concept cooked up by the amazing Niantic Labs at Google (more on this later).

Here is a little about the game before I go into sharing my  thoughts on the game:

The primary goal of the game is defend the takeover of the human race by an unknown “Shaper” force or, depending on your perspective, to assist in an “Enlightenment” of mankind through an alliance with the Shapers. This is accomplished by aligning with either the Resistance or the Enlightened faction and by creating “Control Fields” over geographic areas. Progress in the game is measured by the number of Mind Units controlled by each Faction (visible on the Intel Map).

XM Control Fields are established by claiming Portals and then linking Portals together to form Fields. More powerful Portals can link over longer distances (up to hundreds of kilometers). The link range of a Portal is determined by the power of the attached Resonators. Portal Keys are needed to form links.

When three Portals are linked to form a triangle, a Control Field is established over the region. It will be rendered on the Scanner as a hazy blue or green field over the area. The number of Mind Units claimed is related to the population density of the area covered. Cities yield more Mind Units than rural areas.

Your ultimate goal is to cooperate with other players in your Faction to secure or liberate the entire world.

Now first off it’s worth saying that I primarily am not a gamer though this caught my eye and given the hype I was seeing I just had to get involved, it seemed very much like V to me and I simply love that programme (old and new).

Getting into a closed Beta is not easy as many folks who are desperately trying to get a code to join the game will confirm however one of the brains behind the game, Brandon Badger, who is the Product Manager for Niantic Labs at Google has decided to hand out some codes to people who show artistic skill in relation to the game itself.

Having followed the stream of folk trying to get one of the invites closely, I decided that I would try myself and get an invite with this entry:

And there it was! Enough to get me a coveted spot in the open beta…

The doors were finally opened and no longer would I see the screen taunting me for an activation code.

Upon opening the game and inputting the activation code I was greeted with a ToS page and a warning that saving the world was dangerous… if I wasn’t already hooked I am now!

After completing the initial sign up the game then starts to find your location and gives you an overview of the

game in true game scrolling story type style.

When you have gone through the introduction you receive an incoming message from ADA which advises you that you need to collect Exotic Matter (known as XM) and in a matter of seconds following you clicking Start Training the game pinpoints where you are in the world down to street level and you are instantly shown a map with more XM than you can imagine (purple moving dots).

Your first mission is to collect 1000 XM, which is not easy! This is probably the only game I have ever known to make me want to leave the house at 10:30pm and travel the streets of my town collecting XM. If you don’t move from your settee then very slowly parts of XM will move into your radius and you will collect them being confirmed by a computerised voice advising you of your new XM levels.

Inside the console there are several options open to you so we will go through them one at a time in an overview sort of fashion.

• COMM :The communication hub. Your in game actions are broadcast here and you have the ability to talk too however in my area there was very little chatter. The comm section allows you to communicate  Localally, Regionally and at a Global level.
• ITEMS: As I do not yet have items it’s hard to say what will show here though I can imagine it will be XMP’s will be (XM Bombs)
• INTEL: This shows a world map with both factions being shown. More to come on this later as we move through the game
• MISSION: This shows a list of current and future missions and allows you to abort or view the briefing for each one.
• RECRUIT: This speaks for itself, an area for you to recruit new members however I have 0 invites right now, sorry folks.
• DEVICE: This is essentially the settings area and you can see the options which are available in the screenshots below

OK so now that we have taken a quick walk through of the app and have an idea what needs to be done it’s time to head out and collect some XM to get going!

I will keep you all cheap viagra online informed of the progress as I progress through the game – we hope you join us or stick around to find out more.

Some sites to check out first for you all though:

• Ingress – http://www.ingress.com/
• Niantic: http://www.nianticproject.com/
• Ingress Help and Training Support – http://support.google.com/ingress

Some overdue love for my original Android game today – an update for both Abduction! and Abduction! World Attack.

The main change is better support for the larger screens on high-end phones. Backgrounds should now fit the screen properly on all phones, although there are still issues with some tablets.

I also remade some of the graphics that have bothered me for a while, like the parachute images and some of the platform graphics.

As usual, the update also includes a few general bug fixes.

It's one of those things that you read about, but are never really sure about: you think "maybe he was doing something fishy, and isn't tellling it straight in the public account of the incident".

So I'll try to stick to "just the facts".

A few weeks ago, I dug up some old book reviews I'd done, and posted to Facebook, and opened a site here: http://davids-book-reviews.blogspot.com/ as a way of collecting them.  Naturally, I also added Amazon referral links, because, hey, it helps feed my reading habit!  Last month I got enough to buy two whole Kindle books, so we're not exactly talking about "get rich quick" territory here.  We're not even talking about anything remotely close to my day job, for that matter.  But hey, if I can get a little bit extra to spend on books, it's nice.  The reviews were basically quick notes on books I read.  Nothing that I or the rest of humanity can't get along without, but I felt like writing up a little something for myself and people I know on the internet - maybe it'll help someone else find an interesting book to read.

Several days later, I believe on October 8th, I woke up to find my phone was 'not signed in to Google', and, after repeated attempts, wouldn't sign in.  Same thing with my Nexus 7.  Logging in to my computer, in something of a cold sweat at this point, I find I can't get into Gmail or anything else, either.  Luckily, on the computer, Google's system did redirect me to a page where they mentioned suspicious activity, and gave me the chance to reactivate things by sending an SMS to my phone.  This did work quickly, and did a little bit to alleviate some of my stress.  I understand that locking things down quickly is probably to my benefit as well as theirs in the event of an actual security breach of someone's account: it keeps the attacker from doing any more damage.  However, it was sure a bad way to start a Monday morning.

However, the actual 'blog' (sorry, I hate the word!) was still blocked. It too has a form to fill out to prove that you're human.  Although: as a computer guy, you'd think that with all the clever people at Google, they would be able to tell from my access patterns to the site, browser footprint, IP addresses and so forth, that...well, I am me.  In any event though, they promised to review the blog within two days.  So, I waited patiently.  A week later, still nothing.  Then, the next day, I went back to check on the status, and they had reset the review request: it no longer said anything about October 8th, when I had originally made the reinstatement request.  So I filled in their form again, asking to have my blog back.  That was yesterday, we'll see what happens next.

As far as I can tell, I did not violate their actual terms of conditions, which say nothing about referral links: http://www.blogger.com/content.g

Since the people at Google are loth to speak with their users directly, it seems as if one of the best ways of getting support is to complain loudly and publicly about this kind of shennanigan.

And to forestall the somewhat inevitable comments on anything related to Google: 1) Yes, I know I signed an agreement where they say they can do whatever the hell they want and I can f**k off if I don't like it.  Try and do anything on line with a major company and not get a contract like that, or for even more entertainment value, try and negotiate the contract with t he company.  Good luck.  If you don't say yes, you're pretty much on your own; there doesn't seem to be much of a market for "more humane terms and conditions" out there. 2) I know, I know, relying on the Google beast is a great way to set yourself up for a big fall if anything ever goes wrong, because it's impossible to appeal, or pretty much even to talk with a human.  But with a limited amount of time in my life, to date, Google has been a pretty good deal.  I suppose it's something of a "black swan" situation: everything seems fine until one day WHACK, and Google pulls the carpet from under your legs.

Conclusions?

Well, I hope someone out there can help me recover my content.  I wrote it myself, and I would like to save my book reviews somewhere.

What alternatives are there to the Google colossus?  Not too many that I can see that are anywhere at all as convenient.

Edit: 2012-10-17: I don't know what did it, but they have reinstated the site.  Strange and disconcerting, but I guess things are ok for the time being.  Thanks to whoever it was at Google that finally had a look.

Recently I’ve been working on an Android app where I needed to plot some values in a time-based graph with live data (e.g. the phone’s signal strength). There are quite a few open-source Android charting libraries available that I’ve tried so I’ll just post the links in case someone wants to give them a go. So far I’ve tried:

Snowdon – pretty light, nice for static graphs but too simple for my purpose

Chartdroid – intent-based charts

Droidcharts

AFreeChart – they have an interesting example in the latest version (0.0.4) in Miscellaneous > Performance Test 01. However the sources for that activity are not included in their open source code but if you decompile the .apk you’ll be able to see the entire code, it’s not obfuscated. However, I found the library to be quite slow/sluggish for some reason, even on JellyBeans.

AChartEngine – my favorite charting library so far, the code is open source, with plenty of demos to browse through. There are also a lot of answered questions on StackOverflow which helped me a lot and I found it quite suitable for my purpose. The only thing I wish it had is bellow-the-line gradients for line charts (so far gradients are supported in bar charts) but I took a look into the code and I have an idea about how to implement it so maybe I’ll contribute in the future..

I’ll just post below an working example of using AChartEngine in a live line chart graph that scrolls to the right as values are added. It also supports zooming (with external controls).

As a picture is worth a thousand words, my live graph looks like below.

I’ve simulated slowly plotting values in range of [0-100] using random generated colors for each series and I also displayed horizontal threshold lines. Although you can use intents to display your graphs, you can also use ChartFactory to retrieve a GraphicalView that you can embed in an activity or a fragment. In my example, the graph is a Fragment (I also use the compatibility library).

The interesting bit is to get the TimeSeries scrolling as you add in more values. For that you need to set the range of the renderer so that the the x-axis (the time axis) is always centered on now, with some padding of a few seconds before and after. Same thing for the y-axis, if you want to re-arrange the graph based on the minimum and maximum of the values displayed (I’m sure the thinking behind this one can be improved…).

Also you need to take into account the zoom level so that zooming out, zooming in or resetting the zoom works properly with the new ranges. In my graph, zooming makes sense on the x-axis, where I want to display more or less time between the values (so I can see more values or less values at once).

Last, in my case I wanted to hide some of the texts in the legend area, so I use a modified version of the library where I just created an extra check if the legend text is null or empty to completely skip displaying it. This is not in the default library but feel free to use my modified jar if you want the same behavior.

As usually, the full working source code is available in my Git repo called CodeAndMagic

Enjoy!

Hey everyone,

Just got an email from Packt Publishing with the exciting news that they’ve published their 1000th title! Pretty impressive no?

Any ways, to celebrate:

————————————————————————————————————————————————————-

Dear Customer,

Packt Publishing has come a long way since it published its first book in 2004, and is now one of the leading technical publishers, renowned among developers for its focused and practical books on a wide range of tools and technologies.

Packt has just published its 1000th book. You are invited to join us in celebrating this milestone with a gift. Access our library, PacktLib, for free for a week, and choose any of our eBooks to download and keep.

To make use of this offer, you simply need to go to www.packtpub.com and log into your account, or register for an account, between the 28th and 30th September.

At Packt, we really appreciate your support in helping us get this far, and hope that you will continue to enjoy our range of books.

Kind regards,

Packt Publishing

————————————————————————————————————————————————————-

So yes – check out the resources they have and go get your free e-book! I’m definitely going to redeem mine =)

And PS, for those who don’t know, I happened to publish my book with Packt so if you’re interested feel free to download my e-book at Android Database Programming.

Happy coding as usual!

- jwei

Hey everyone,

For this post, I thought I’d revisit the topic of Intents. In the past I’ve talked about passing Intents in between classes with simple, primitive data (see Passing Information between Activities) – turns out it’s a relatively easy task, and a core concept within the Android framework. However, the much harder task is passing your own classes (objects) in between Activities, and moreover, potentially passing lists of objects.

In this post, I’ll go through an example of writing an object that implements the Parcelable interface.

Consider a scenario where you have a list of Venues (i.e. Restaurants, Hotels, Clubs, anything with fields for lat, long, name, address, etc). Your user makes a request and gets back a list of these Venues. You then want to pass these results to a new Activity – maybe it’s a mapping Activity (as it was in my case), but regardless the goal is to pass this list of Venues from Activity A to Activity B without having to make the same request twice.

The first step is defining your object. The object must implement the Parcelable interface. Why you might ask? Well let’s step back and think about what’s happening here. Within Android, much of the inter-process (inter-Activity) communication is done through light weight data structures known as Parcels. In fact, both Intents and Bundles (two objects you’ve probably encountered before…) implement this Parcelable interface.

But how does this inter-process communication work? An Android process first converts an object into a byte stream which is then sent to another process (i.e. another Activity). This second process then reads in the byte stream and converts it back into an object: this exchange is more commonly known as serialization or marshalling. But how do the two Activities know what to do to serialize and de-serialize your object? For primitives like ints, doubles, even Strings, serialization is trivial as these primitives are already in byte form. And so this is where the Parcelable interface comes in.

By implementing the Parcelable interface, you are essentially giving the OS instructions on how to serialize and de-serialize your object. Conceptually this may be difficult to picture, but luckily Android has made the code for this super simply – in fact you are only required to override a few methods. With that, let’s take a look at what exactly needs to be done in the implementation:

public class ParcelableVenue implements Parcelable {

	private double lat, lon;

	private String name, address;

	public ParcelableVenue(double lat, double lon, String name, String address) {
		this.lat = lat;
		this.lon = lon;
		this.name = name;
		this.address = address;
	}

	public ParcelableVenue(Parcel source) {
		// TODO implement
	}

	public GeoPoint getGeoPoint() {
		return new GeoPoint((int) (lat * 1e6), (int) (lon * 1e6));
	}

	public String getName() {
		return name;
	}

	public String getAddress() {
		return address;
	}

	@Override
	public int describeContents() {                     // OVERRIDE METHOD #1
		return 0;
	}

	@Override
	public void writeToParcel(Parcel dest, int flags) { // OVERRIDE METHOD #2
		dest.writeDouble(this.lat);
		dest.writeDouble(this.lon);
		dest.writeString(this.name);
		dest.writeString(this.address);
	}

	public static final Parcelable.Creator<ParcelableVenue> CREATOR = new Parcelable.Creator<ParcelableVenue>() {

		// TODO implement

	};

}

So far we have the basic structure of our ParcelableVenue object – it has a few simple fields as well as some standard getters; nothing special there. You’ll then notice that there are two methods we need to override. The first is the describeContents() method. Typically returning 0 suffices unless you have numerous parcelable objects and require special serialization for some. The method itself is meant to return a bit mask that identifies the serialized object. In my case, I just return 0.

The second method is the writeToParcel(Parcel dest, int flags) method. The meat of the conversion happens here. In this method you are passed a destination Parcel which is eventually serialized and sent to the end process. Thus you simply need to write your object’s data into this parcel. Luckily, some simple write methods are given to you, such as writeDouble(), writeString(), writeInt(), writeIntArray(), etc. The flags parameter simply tells the writeToParcel() method how the object should be written.

Once these two methods are overridden, every class that implements the Parcelable interface then needs to have a static Parcelable.Creator object named CREATOR. Let’s step back one more time – where are we at this point? Well so far we’ve flattened the object and written it to a Parcel object. Our object is in essence nothing but a byte stream now, so the only thing that’s left to do is un-flatten it and convert it back into an object using this CREATOR object!

Our creator object is pretty simple and need only look like:

public class ParcelableVenue implements Parcelable {

	private double lat, lon;

	private String name, address;

	public ParcelableVenue(double lat, double lon, String name, String address) {
		this.lat = lat;
		this.lon = lon;
		this.name = name;
		this.address = address;
	}

	public ParcelableVenue(Parcel source) {
		// TODO implement
	}

	// ...

	@Override
	public void writeToParcel(Parcel dest, int flags) {
		dest.writeDouble(this.lat);
		dest.writeDouble(this.lon);
		dest.writeString(this.name);
		dest.writeString(this.address);
	}

	public static final Parcelable.Creator<ParcelableVenue> CREATOR = new Parcelable.Creator<ParcelableVenue>() {

		@Override
		public ParcelableVenue createFromParcel(Parcel source) {
			return new ParcelableVenue(source); // RECREATE VENUE GIVEN SOURCE
		}

		@Override
		public ParcelableVenue[] newArray(int size) {
			return new ParcelableVenue[size]; // CREATING AN ARRAY OF VENUES
		}

	};

}

And so we see that the very last step is simply to write another constructor for our ParcelableVenue class which initializes an object given a Parcel. This can be done with:

public class ParcelableVenue implements Parcelable {

	private double lat, lon;

	private String name, address;

	// ...

	public ParcelableVenue(Parcel source) {
		this.lat = source.readDouble();
		this.lon = source.readDouble();
		this.name = source.readString();
		this.address = source.readString();
	}

	// ...

}

The order here is important – the first double read will be the first double written as, again, it is a byte stream.

And that’s it! Once we have our ParcelableVenue, we can then do things like:

public class ClubsListActivity extends ListActivity {

	private List<Club> clubs;

	private Button mapViewButton;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.club_list);

		mapViewButton = (Button) findViewById(R.id.switch_map_view);
		mapViewButton.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// PREPARE NEW INTENT TO SEND TO MAP ACTIVITY
				Intent i = new Intent(ClubsListActivity.this, VenueMapView.class);
				
				// INITIALIZE NEW ARRAYLIST AND POPULATE
				ArrayList<ParcelableVenue> overlays = new ArrayList<ParcelableVenue>();
				for (Club c : clubs) {
					overlays.add(new ParcelableVenue(c.getLat(), c.getLon(), c.getName(), c.getAddress()));
				}
				
				// EMBED INTO INTENT
				i.putParcelableArrayListExtra("venues", overlays);
				startActivity(i);
			}

		});

		SharedPreferences sp = getSharedPreferences(Constants.DB, Context.MODE_PRIVATE);
		double lat = (double) sp.getFloat(Constants.SP_PREV_LAT, (float) Constants.DEFAULT_LAT);
		double lon = (double) sp.getFloat(Constants.SP_PREV_LON, (float) Constants.DEFAULT_LON);

		// GET CLUBS NEAR YOU WITH LAT LON
	}
}

The receiving side then looks like:

public class VenueMapView extends MapActivity {

	private MapView map;

	private List<ParcelableVenue> venues;

	@Override
	protected void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		setContentView(R.layout.mapview);

		SharedPreferences sp = getSharedPreferences(Constants.DB, Context.MODE_PRIVATE);
		double lat = (double) sp.getFloat(Constants.SP_PREV_LAT, (float) Constants.DEFAULT_LAT);
		double lon = (double) sp.getFloat(Constants.SP_PREV_LON, (float) Constants.DEFAULT_LON);

		map = (MapView) findViewById(R.id.venue_map); // INIT MAP
		map.setBuiltInZoomControls(true); // SET MAP CONFIGURATIONS
		map.getController().setCenter(new GeoPoint((int) (lat * 1e6), (int) (lon * 1e6)));
		int maxZoom = map.getMaxZoomLevel();
		map.getController().setZoom(maxZoom - 3);

		Intent i = getIntent(); // RETRIEVE OUR INTENT
		venues = i.getParcelableArrayListExtra("venues"); // GET PARCELABLE VENUES

		List<Overlay> mapOverlays = map.getOverlays();
		Drawable icon = this.getResources().getDrawable(R.drawable.good_pin);

		VenueOverlay vo = new VenueOverlay(icon, this); // INIT OVERLAY MARKERS
		List<OverlayItem> points = new ArrayList<OverlayItem>();
		for (ParcelableVenue v : venues) {
			OverlayItem o = new OverlayItem(v.getGeoPoint(), v.getName(), v.getAddress());
			points.add(o);
		}

		vo.addOverlayList(points);

		// ADD VENUE OVERLAYS TO MAP
		mapOverlays.add(vo);
	}
}

I won’t say too much about what I’m doing with my Maps Activity – maybe I’ll save this for a future tutorial. The important thing to see is how I send a list of ParcelableVenue objects, and then retrieve them on the other side. As you can probably see by now, there’s nothing hard code wise when implementing a Parcelable object. The difficulty typically stems from an incomplete understanding of how Android sends data from process to process – and this is understandable as almost all of this is abstracted away so that we only need to put simple values into Bundles and Parcels and voila things magically appear on the other side. But once you dig a little more into what’s happening behind the scenes, then all of this serialization and Parcelable implementation makes much more sense.

And with that I send you off again! Happy coding and hope this helped.

- jwei

Even if my day job is keeping me very busy, I’ve just managed to publish my very first open source Android library for drawing gauges on Canvas I’ve implemented this in a couple of days so the code is still a bit messy, no documentation etc. I’m planning to work over the next few weeks to add a tutorial, some javadoc and some more examples. But until then, the code is available on Github

It’s licensed with Apache 2.0 so feel free to download it, modify it etc. etc. Any suggestions on how to improve it are more than welcome Enjoy!

GaugeView

Back in March, I complained about a crowded notification drawer, and hey, look, they fixed it. (Even if any given app isn't on board with this yet, hello apktool/baksmali, bye bye notification icon.) So, clearly I should complain more often. :-)

In that spirit, then, a question to app authors, including myself: why do my phone and I need to check so many different places for news from my friends and blogs? It's polling these all day. (All night too, which is silly, as I'm asleep.)

RSS in particular: my phone really doesn't need to poll 60 different hosts. Google Reader is an incomplete solution, because it doesn't understand private/authenticated feeds, but does show that an aggregation server can make this much less painful, for apps that can afford one. As well as the aggregation, this allows better update schedules: push anything important (replies/messages addressed specifically to me), use a slow inexact alarm to get the rest. More details here: Minimizing the Effect of Regular Updates. Many apps, individually, already do these things. The ones that don't mostly should.

But I also want to aggregate things from a UI point of view. Strangely enough, I don't actually like checking an ever-increasing number of apps/websites any more than my phone's battery does - and I often have disconnected views of it on my phone versus other devices. My ideal is a single news stream: tweets, blog posts, news, the lot, viewable on the web (my own server) or Android, with the aforementioned sync strategy, including read/unread.

Android allows all this today, and the social stuff in 4.0.3 might be a good, well-integrated foundation, but it's still intended only as a preview, not a replacement of a service's own app. The spanners in the works are social sites who don't like being aggregated, in particular Twitter and Facebook. Twitter is preparing to kill off "consumer"-facing clients, but, happily, many users seem prepared to move away from Twitter as a result. The less said about app.net the better, but Tent looks interesting.

Facebook's a harder problem: many of my friends rightly distrust all Facebook apps and opt out of the "platform", meaning their posts can only be seen in the browser (or possibly Facebook's own app, which I won't install because it'll run off home with my contacts database). Result: I reluctantly check the site occasionally because of people who post nowhere else, and will eventually get around to leaving when there are few enough such people. They don't seem keen to move any time soon, and I can somewhat understand that, because there aren't many good places to jump to. Most of the alternatives lack features, and all of them lack users (some of them deliberately exclude users - looking at you, G+/#nymwars).

For many people, they already have their single stream of everything. It's called Facebook. And they don't care that their posts are locked in. Yet. I can only hope that some other site gets popular enough that people are prepared to cross-post (Facebook, for the moment, remains receptive to importing content). Then, eventually, I no longer need to care about Facebook. The hard part, obviously, is for any other site to get popular enough.

Comments preferred at http://chris.boyle.name/2012/08/supercalifragilistic-social-aggregation using OpenID/Facebook/Twitter (comments elsewhere are unlikely to reach me).

I wanted to post a quick note just in case anyone else runs into this issue or I forget it later on.

jMdns is a great java library to provide zeroconf/bonjour capabilities to your Android application.  I was successfully using this in a project up until Android 4.0 “Ice Cream Sandwich” aka ICS, once Android 4.0 devices were starting to be used more often I was receiving user reports that the application was not working.  I knew it was a jmdns issue, I just didn’t have an ICS device to be able to track down the issue.

Well I was at Google I/O this year and picked up a few Jelly Bean (Android 4.1) devices.  Both of these devices have the same issue that was being reported by Android 4.0 devices, basically the zeroconf functionality was not working.

It took me quite a while to track down but I figured out the problem.

Most jmdns Android tutorials instruct you to create your jmdns object by calling “jmdn.create();”.  This works fin in Android 2.x and 3.x, but does not always work with Android 4.x

To fix the issue use the “jmdns.create(String Hostname);” constructor passing in the ip address of your wifi connection which can be obtained from a WifiInfo object from the Android WifiManager service.

Hopefully this helps people in the future, it seems something changed between Android 2.x/3.x and Android 4.x where the default jmdns.create() function is no longer bound to the regular wifi interface.

We all hate it, the constant Apple harping. How Android is a botnet, fragmented, and slow. How it doesn’t support the end user and how Apple does everything so much better. And we all had those discussions. So, here, without much further ado, are my arguments. Help me (and everyone else) out and comment with yours.

The Android world is fragmented and everyone puts their own overlays on things…

Linux “fragmentation” according to DistroWatch. Funny how a so fragmented OS still runs the Interwebs, eh?

True, but that’s a good thing. Android is as much based on Linux as it is based on the general idea that an open OS can and should be adapted by individuals to serve each individual’s needs. Luckily we’re not all cut from the same cloth and have different tastes. Apple, in its own 1984 commercial, noted just that – that same-same drones aren’t the future.

In that vein, Android is an OS as Linux is. And, like Linux, individual distributions use individual approaches above and beyond the system and kernel. SuSE, RedHat, Mandriva, Ubuntu, Mint, all have their own desktops and apps. We all have a choice which carrier and which hardware, OS, and software provider we want to go with. To Joe Random Phone User this is an easy choice – all Android phones perform well and do what they’re supposed to do – be a smartphone. To those of us who have specific needs, better sound for example, a better camera, NFC, strong batteries, or a rugged case, Android can and does power those. It’s about choice, here. Demeaning choice as “fragmentation” might be a good marketing gag but it doesn’t hold scrutiny in the face of reality. And, coincidentally, it flies directly into Apple’s old promise.

Not everyone runs Ice Cream Sandwich or Jelly Bean and carriers/phone makers are slow to update

Somewhat true and then not true at all. We all have used today one or more of those services, haven’t we? Facebook, Twitter, eMail, some website somewhere, Pinterest, Quora… or whatever else there is out there, running on one or more servers. Linux, currently, is at kernel version 3.5 yet a majority of the services above still run a 2.6 kernel. RedHat Enterprise is at Sever version 6.3, yet at least two of the big ones above run Server 5.x versions. Why? Because they work and do the work well. There isn’t always a need to stay totally current. Some people want to and, with Android, they can. Some people run Windows 8 right now or Mac OS X 10.8 Developer Preview. And some people don’t. No one would assail Mac OS just because a huge amount of modern Macs still run OS X 10.6, now, would they? Android is not that much different. The latest and greatest is not always the bestest. Sometimes an older, well managed, well maintained, version works just as well, if not better.

Size management in Eclipse

All these screen sizes and hardware capabilities make coding for Android a nightmare

Personally, I find it more of a nightmare to be locked in to one hardware and software system. Every coder who writes software for desktops containing graphical interfaces knows what it means to keep different hardware specs in mind. This isn’t an Android issue, this is a common consideration for anyone but iPhone/iPad programmers. Some people run software on an old Pentium 4 and 4G of RAM on a 19″ monitor. Some use the fastest hardware and software and SLI their graphics cards together. And some, like me, are somewhere in between. On desktops we take this for granted and program for it. On Android, suddenly, it’s an issue? Not really. Especially since Google is very active on this front and will release a new Layout Editor Windowing system soon in which every possible layout can be shown, side by side, and updates in real time. Even with warnings and hints. Today, well, it’s a click of a button. Still nothing too demanding. Seriously, watch the five minutes from the point I liked, it’ll make you scream in joy.

Android “fragmentation”. Used by Apple fanboy site Boy Genius Report to malign Android. We think it’s a good thing.

Hardware Vendors are going wild, with Apple I know what I have

Yes, “wild” isn’t the right word, though. In Android the hardware and software ecosystem are disjoined. This comes with some challenges (Apple users call them “problems”) but has one massive advantage: no lock in. I don’t know about you, but I have a few hundred dollars spent on apps in the Play Store. If, for some reason, Samsung stops making phones or starts making phones I don’t like, the next Nexus phone is made by Motorola, or I am moving to Germany or Iceland and am switching carriers and phones, I take all those things with me. Not so with Apple. Should the iPhone 6 suck big time or Apple decide to stop selling in Germany I am hosed. With Android I have access to all my purchased apps, regardless which carrier and hardware I choose to go with. Even if Google abandoned Android, its Open Source nature would not let it die. If Apple goes to the “next big thing” in five years its users are either following or dying out.

There are so few Tablet apps for Android

From an iPad users standpoint this makes sense. On iPad most iPhone apps look like … errm, well. Android makes this much easier by allowing multiple resources and layouts in one app. Not only that, there’s a marked difference between Apple’s upscaling of pixels to fill the screen and Android’s intelligent layout manager. A good example is the WoW Remote for iPhone and Android. Neither come in a native tablet version. On iOS the remote either sits, phone sized, in the middle of the iPad or all pixels are magnified, giving it a blocky look. On Android an intelligent layout manager swaps things around and uses the tablet’s full size to display more information in a crisp and optimized way.

Android steals everything from iOS and iPhone designs

Crock. While it might be true that Apple patented a few things they, themselves, did not invent, this is more a two way street than a thief and victim situation. Notifications in a pull down bar? On Android long before it was on iOS. Synced bookmarks? Just now coming to iOS 6, in Android since 2.3. Turn by turn voice nav? On Android since 1.5, not even supported in iOS 6 on most devices. And, yes, it works on my five year old phone, it won’t work on a two year old iPhone. Over the air updates? A staple of Android since its inception, just now in iOS. And don’t get me started on Siri. Yeah, she’s a smart one, but voice search was in Android forever, even if no one used it.

This is just the beginning

There are more, but those are the big ones I keep hearing all the time. Let’s stick our heads together and finish this off together. We’re a smart community of hackers, designers, thinkers, and doers. Our phones are tools, not fashion statements, and we’d be darned if we can’t come up with a rebuttal to all those Apple myths… let me have it in the comments.

There’s been quite a bit of debate in the Android keyboard community lately if, and how, Jelly Bean’s new keyboard makes Swiftkey obsolete. Here at Andromancer Central we’re still big fans of Swiftkey 3 and, of course, not disinclined to a few hours in front of the telly, watching the games.

Which makes it even sweeter that Swiftkey announced today an update to its UK and US language packs to include Olympic words and sentences. Now if you want to live-tweet women’s synchronized swimming (the only thing anyone seems to have gotten tickets in the lottery for), you can.

Hi everyone!

In spite of trying hard, I couldn’t prevent the delay. I am again sorry for that. Let’s move on. In the last post, I introduced the concept of transfer of data between activities. I also described the code for declaring an Intent which could help us in accomplishing the task.

Now, it’s time to look at the code of SecondActivity.java, the second activity which will help us in adding new tasks to the list. As mentioned earlier, this activity will have an EditText to allow the user to input the task name and a Button, which when clicked, will take the user back to HelloWorldActivity.java and add the task to the List. The code for the click listener for this button looks as follows:

1. String taskName = taskEdit.getText().toString();
2. Intent intent = this.getIntent();
3. intent.putExtra(“task”, taskName);
4. setResult(RESULT_OK, intent);
5. finish();

Here, taskEdit is an object of class EditText. The first line extracts the data input to the taskEdit, converts it into string and stores it in a variable. Second line is used to grab access to the intent which called this activity. The third line is the one which actually does the job of putting the data onto the intent. intent.putExtra function used in this line basically adds the information contained in the second parameter to the intent and the first parameter provides a way to access it. We will see the use of the first parameter in a greater detail later, when we will try to access this information in HelloWorldActivity.java. I hope that the fourth and fifth lines will be pretty easy to understand. If not, please refer to the last three posts on Intents.

The above code ensures that the clicking of the button takes us back to the initial activity with an intent which contains the name of the new task that is to be added to the list.

Clearly, the callback function described in Part 1 of this post will be used to access the information carried by the intent since this function will be automatically called when the control is given back to this activity via an intent. Straight away, let’s look at the code!

String extraData=data.getStringExtra(“task”);
taskText.append(extraData+”\n”);

I think it is self-explanatory. We are extracting the information from the variable data using the value of the first parameter of the function in Line 4 above, and saving it in a variable called extraData. The second line just appends this value to the list (referred by taskText).

In this way, we received the name of the task from a different activity and display it in our main activity. This provides a clean and user-friendly interface which is the basis of a useful app.

But here, we have not taken care of the situation when the user calls the intent to SecondActivity.java but wants to cancel it later. This is not perfect programming, though it can be dealt very easily. How?

In the next post, we will finish our discussion on intent and move on to explore some new concepts in Android App Development.

Till then, BYE!

Up until yesterday, I thought that enabling ProGuard for an Android project would be just adding one or two lines somewhere. I was kind of right — it was adding a single line to enable it, and a day of Googling and experimenting to get it actually working.

I wasn’t using the latest SDK tools when I started, but while fiddling everything I upgraded to Android SDK Tools rev 20 and Android SDK Platform-tools rev 12, so the following applies to those versions, but might work for earlier or future versions as well.

During the trial and error process I encountered several different errors, some of them being more common than others.

The first problem was easy to find a solution on the web; ProGuard was throwing out warnings about the support-v4 library. Those just had to be disabled by adding an extra line to proguard.cfg:

-dontwarn android.support.**

After which there was my first encounter with the dreaded  ”Conversion to Dalvik format failed with error 1″ failed. This kept appearing and disappearing a lot. And as there is absolutely no logs as to why it happened my only guess is that ProGuard failed to produce Dalvik compatible bytecode — which in turn means something is wrong somewhere.

There are many-many alleged solutions to this problem on Stackoverflow, but most of them had little or no impact on solving the problem. However, two of them combined worked for me.

First, you need to double-check your build paths (Project Properties → Java Build Path) and under the Source tab remove all <library_project>_src folders if you have any; and under Libraries tab you want to remove everything except the Android x.x. After having done that you need to re-add the library dependencies by invoking Android Tools → Fix Project Properties.

Second, there appears to be an annoying bug in the actual ADT themselves that mess with ProGuard somehow. What you need to do is disable automatic building in Eclipse (Project → Build Automatically), then clean your entire project and then rebuild it (Project → Build All). Credits for this step go to Regex Rookie on Stack Overflow.

There was a third problem as well, some IllegalArgumentException in ProGuard, saying that some method in the compatibility library was using something from SDK v14 and it couldn’t find it.

Unexpected error while evaluating instruction:
  Class       = [android/support/v4/view/AccessibilityDelegateCompat$AccessibilityDelegateJellyBeanImpl]
  Method      = [newAccessiblityDelegateBridge(Landroid/support/v4/view/AccessibilityDelegateCompat;)Ljava/lang/Object;]
  Instruction = [18] areturn
  Exception   = 1 (Can't find any super classes of [android/support/v4/view/AccessibilityDelegateCompatIcs$1] (not even immediate super class [android/view/View$AccessibilityDelegate]))
Unexpected error while performing partial evaluation:
  Class       = [android/support/v4/view/AccessibilityDelegateCompat$AccessibilityDelegateJellyBeanImpl]
  Method      = [newAccessiblityDelegateBridge(Landroid/support/v4/view/AccessibilityDelegateCompat;)Ljava/lang/Object;]
  Exception   = 1 (Can't find any super classes of [android/support/v4/view/AccessibilityDelegateCompatIcs$1] (not even immediate super class [android/view/View$AccessibilityDelegate]))
java.lang.IllegalArgumentException: Can't find any super classes of [android/support/v4/view/AccessibilityDelegateCompatIcs$1] (not even immediate super class [android/view/View$AccessibilityDelegate])
	at proguard.evaluation.value.ReferenceValue.generalize(ReferenceValue.java:287)
	...

Solution for that was simple: bump up the target SDK version of the project to the latest one. Only thing to watch out with this one is that backwards compatibility stuff won’t be used when you run your app on newer platforms now – so you need to know what has changed in the platform and take that into consideration (ie with v14 the default AsyncTask behaviour changed).

And to recap, the check list for getting ProGuard to work:

1. If using support library, bump up your target SDK to latest and add -dontwarn into proguard.cfg
2. Check your build paths for rogue entries
3. Disable automatic building, clean everything and rebuild

Hope this saves someone a couple of hours trying to figure this out.

With the huge demand for applications to be low-cost or free in the Android ecosystem, it can be difficult for developers and publishers to monetize from their work. A high quality application with hundreds of hours invested deserves adequate compensation, and in turn would help fund future high quality applications. Many low quality applications seek to makeup for the lack of invested hours by aggressively stacking advertising into each individual app. But where do we draw the line with advertising? How much advertising is really necessary for an application to make a profit? Do low quality applications deserve to net a larger profit by including many forms of advertising, or should they be limited in relation to the amount of effort and time invested?

read more

Hi all!

Last time, we had looked at the most basic communication which can be achieved among activities. It allowed us to switch between activities back and forth, which is an important concept used in almost all the android apps these days.

Moving on, it’s time to look at the data transfer using Intents. Consider the case of a simple Task application, in which a To-do list is shown in one activity while another activity performs the task of adding new items to the list. So, what’s happening here?

Basically, we need to create a new task in the second Activity and somehow transfer it to the first activity so that it could add it in the existing list. Note that we are not using any database. If we do so which is done most of the times, this app will be useless in itself. But, I am still discussing this app because I feel that it’s the best in order to understand the concept of transfer of data which you may need in various other apps.

In this post, I will not go through the layout or the entire code of the app. I may go through it later. But, I hope that you will be able to do so after going through the previous posts. As a hint, we will be using a TextView (to display the list) and a Button while making the first activity, while the second Activity will have an EditText and a Button.

Assuming that we have an EditText in the second Activity and when the user presses enter, the string in the EditText is captured in a string variable called NewTask, we need to simply tranfer the contents of NewTask to the first activity.

To achieve this, we need to call the intent when the button in pressed in the first activity in such a way that the Android platform knows that some data will be coming back to this activity. Continuing with the app from the previous post by replacing the startActivity(intent); by

startActivityForResult(intent, 1);

1 as a parameter acts as a unique code used to distinguish data received by this intent from the data received by other intents if more intents are used. Using the above functin, we have been able to call the intent, but we have not yet accessed the data which comes back with this intent.

To achieve this, we need to use a callback function which will called automatically when the intent returns. Let’s look at the code for this function:

public void onActivityResult(int requestCode,int resultCode,Intent data)
{
          super.onActivityResult(requestCode, resultCode, data);
          if(resultCode==RESULT_OK)
          {
                      //Code to extract the required information from the variable data
          }
}

In our case, requestCode is 1. resultCode is a variable which is set to value RESULT_OK if the intent was successfully handled. data is the variable which contains the data received from the other activity.

In the next post, we will look at the code to extract the information as well as the code for the second Activity which puts the information in the intent.

Till then, BYE!

Kikoriki: The Beginning [by HeroCraft] is yet another arcade adventure android game from the people that brought you Dragon and Dracula. The game is based on the Russian cartoon series “Smeshariki”, but the show is known by different names in other countries.

The characters of the animated series become superheroes in this adventure, which is always fun for kids and adults. Children will probably enjoy it more than adults due to the excruciatingly child friendly atmosphere of the game. However, some grown-ups might give it a go just to try out the various super powers each hero possesses.

Your mission is to vanquish evil and thus save the boring grown up world from destruction. How does one do that? Well, by working together of course, just like best friends should! The power of friendship is demonstrated in the game by allowing the player to switch between two characters during gameplay and use their individual super powers to solve puzzles, defeat bosses and do anything to complete the level.

The three chapters of the story take you from the happy land of Kikoriki to the boring grey Megapolis. Each chapter tells a different story and allows you to play various characters. The game has brightly colored, simple and yet well drawn cartoon style graphics with smooth animation. The controls might take a bit of getting used to, the joystick in particular. I do like the soundtrack, which reminded me of the music from good old cartoons like Tom & Jerry. Kikoriki will only set you back $1, unless you don’t really love your children that much, in which case you can opt for the lite version. Either way, the game will help keep your kids preoccupied and will not only help them learn about friendship and growing up, but will also teach them that if you touch purple butterflies it will make you sneeze stars.

Dragon and Dracula [by HeroCraft] is a fun and challenging arcade android game that is sure to touch the hearts of the Mario and Spyro the Dragon generation. It takes the jumping, coin collecting and shrooms – the inspiration for many 90’s games – from Mario, giving the role of the hero to an increasingly awesome dragon, whose job is to defeat Dracula.

The fact that you start the game with just a little baby dragon that jumps can be disappointing, at first. However, as you progress through the 25 levels of the game, learning new skills, collecting artifacts and battling enemies, you will see the little guy go through three stages of evolution. With every new form the dragon grows, acquiring fire breathing, flying, climbing and head bashing abilities, not to mention a mean look.

The dragon’s natural abilities are enhanced with the always popular temporary perks such as invulnerability, increased speed, regeneration and many more. They will be of great help on the quest to destroy the Dark Lord’s minions and defeat the legendary vampire that is Dracula. Gamers who find the adventure to be unfulfilling can enjoy some mini games that are unlocked during gameplay.

Controls might take a couple of deaths to get used to and actually made me play with my tongue out, which I have not done in a while. The menu is very well thought through, easy to navigate and has all the information on game controls, settings, stats and sharing options. Thanks to the simple yet visually pleasing and familiar graphics, the gameplay is smooth. Not a fan of the soundtrack though, which sounds like old Japanese game techno music. For only $1 Dragon and Dracula has a lot to offer with tricky levels, epic boss fights, addictive mini games and main character customizations. If you are just looking for a fun adventure or want to prove yourself on a global scale, this is the bargain to go for.

Ever since getting my first Android phone, I have loved using the Navigation app to help me get where I’m going, sometimes whether I really need it or not. Androids (and smartphones in general) are good at picking up all kinds of tasks and replacing a regular GPS unit is one of those tasks. There has been a downside though. If you loose 3G coverage, you could be left in the dark.

Other GPS units allow for downloading full maps without constantly needing an internet connection. That’s one of their only real advantages (ok, I’m sure they’ve got other bells and whistles too). Finally, FINALLY, Google has come up with the idea to include offline mapping in the Navigation app. Why it hasn’t been there before now, you got me.

This new feature has only just been announced and a date for the upgrade isn’t even leaked yet. Hopefully soon. We’ll do our best to keep you updated. Meanwhile, check out Android.Appstorm’s article on Google’s latest Navigation announcements.