So I came out with this quick solution, using Kotlin, to pipe multiple processes in Android:

object ProcessUtil {
    private fun check(process: Process, error: (() -> String)) {
        try {
            if (process.errorStream.available() > 0) {
                process.errorStream.bufferedReader().use {
                    it.readText().also { errorText ->
                        check(errorText.isBlank()) { "${error.invoke()} failed with error: $errorText" }
                    }
                }
            }
        } catch (_: IOException) {
            // ignore
        }
    }

    @Throws(IOException::class, IllegalStateException::class)
    fun pipe(vararg processes: ProcessBuilder): String {
        check(processes.size > 1) { "At least 2 processes are required" }

        var previous: Process? = null
        var result: String = ""

        processes.forEachIndexed { index, builder ->
            val cmdString = builder.command().joinToString(" ")
            println("Executing command $index -> $cmdString")

            if (index > 0) {
                check(builder.redirectInput() == Redirect.PIPE) { "Builder redirectInput must be PIPE except for the first builder" }
            } else if (index < processes.size - 1) {
                check(builder.redirectOutput() == Redirect.PIPE) { "Builder redirectOutput must be PIPE except for the last builder" }
            }

            val current: Process = builder.start()
            check(current) { cmdString }

            previous?.let { prevProcess ->
                prevProcess.inputStream.bufferedReader().use { reader ->
                    current.outputStream.bufferedWriter().use { writer ->
                        reader.readLines().forEach { line ->
                            println("writing --> $line")
                            writer.write(line)
                            writer.newLine()
                        }
                        check(current) { cmdString }

                    } // writer

                    if (index == processes.size - 1) {
                        current.inputStream.bufferedReader().use { reader2 ->
                            result = reader2.readText()
                        }
                    }

                } // reader
            }
            previous = current
        }
        return result
    }

    fun pipe(vararg commands: List<String>) = pipe(*commands.map { ProcessBuilder(it) }.toTypedArray())

    fun pipe(vararg commands: String) = pipe(*commands.map { ProcessBuilder(it) }.toTypedArray())
}

And it can be used like this:

    @Test
    fun testPipe() {
        val packageName = context.packageName
        val result = ProcessUtil.pipe(listOf("ps", "-A"), listOf("grep", packageName), listOf("awk", "{ print $9 }"))
        println("result = '$result'")
        Assert.assertTrue(result.contains(packageName))
    }

I like to take pictures, ok, I’m definitely not a professional photographer, but I still like to try to be one 🙂

In particular I like to take pictures at night, I like to take pictures of moving clouds, stars.. etc. And then I like to stack all the photos into a single document. The problem is that most of the times this Photoshop document has hundreds, if not thousands, of layers (and we’re talking about 40MP images) and, despite the fact that photoshop can barely survive after I’ve added all those layers to the document, the real problem comes after that.. In order to create a nice stacking effect it’s not just a matter of changing the blending mode of the different layers, but also to change their opacity.

Unfortunately Photoshop doesn’t have an option to manage the opacity of multiple layers at the same time, like, for instance, from 0 to 100 of all the selected layers.. or even more advanced options.

That’s why I’ve decided to make an extension (available here) for this. This is it’s pretty easy interface:

So basically what it does is: you select a bunch of layers in your document, then you create the bezier curve. Once you click on “Apply Opacity” the opacity of every selected layer will follow the designed curve value. Let’s make it easier. If you design a curve like this:

the first selected layer will have an opacity of 0 (completely invisible), while the last layer will have 100 as opacity. (If you’ve selected 100 layers, then the second one will have an opacity value of 1, the third of 2 and so on..)

These 2 images, for instance, have been created using this extension:

The second one is the result of 1200 layers stacked together and without that extension I would probably still working on it!

And here’s an example of the Extension in action:

For more information and download:
https://www.adobeexchange.com/creativecloud.details.20327.html

I’m an Android developer (at Aviary) and a New Yorker since late 2010. I’ve been also an actionscript and python developer for more than 10 years.

I hear this every day. Your New York based company is desperately looking for an Android developer, and it’s damn hard to find one.

And you know what? This is your fault. I mean you, tech startup. Yes, you.

Almost all the startups I know here in NYC have launched their core product for iOS first (most of the PMs I’ve spoken with have said that was because of lack of people or time). And then, maybe, if there’s time… they start to realize they need to have an Android version of their app. But by this point the job is not to “create” something, it’s just a “porting” job. Which, for obvious reasons, is a much less attractive job for developers, just as it would be for a PM or a designer.

Anyway, ignoring Android at first is somewhat understandable, if you think in short terms and you’re not thinking globally. Here in the US, and even more in NYC, the iOS market share is still very strong: as of this past May, Android has 50% of the share and iOS has 42% nationwide (https://www.comscore.com/ita/Insights/Market-Rankings/comScore-Reports-May-2014-U.S.-Smartphone-Subscriber-Market-Share).
If you remove the huge number of “low end” (not profitable) devices from the Android share – as most people do – you’ll see why I said I can understand it.

But, that said, I don’t agree with it. Because globally, for the rest of the world, things are completely different. Android has 80% of the market share and iOS only has around 12% (http://www.idc.com/prodserv/smartphone-os-market-share.jsp).

Ok, I know the numbers, but why is hard to find Android developers?
Because you are not committed to Android development. You just think you “have” to do that. Because at some point you realize either that you need it to go global, or because a lot of users are asking it, or just because you think that porting your app will double your users overnight.

But you’re not committed to doing it.

And when you start, most of the time it’s with a 1-to-1 porting of your iOS app, or at the very best a porting of UI created ad hoc for an iOS environment, which cannot be applied to Android (although, to your credit, you probably don’t know this because you didn’t bother hiring an Android PM or UX expert). I don’t think I even need to mention the cases where you’ve already given the initial porting to 3rd party companies…

Then, after all of this, you complain because the response of the Android market is not as good as you expected and the profits are not comparable to iOS. Well, I would be extremely surprised if this weren’t the case. You’re not committed to it, and you didn’t build an app that takes advantage of any of the benefits of the platform, so what do you expect?

(When I say committed, I mean all the departments in your company from top to bottom. You can’t say you’re committed to it just because you have an Android team. The whole company needs to acknowledge that it’s a priority.)

Ok, but I still don’t get why it’s hard to find Android developers.
Well, try to think from a developer’s perspective. Android developers don’t find it very attractive to join a company where Android will be always the 2nd choice. That’s very frustrating.

And as for developers who are approaching the mobile market for the first time, which platform do you think they’ll choose? They see all of your apps being introduced on iOS first, they see that the Android version is not as good as the iOS one, and they see you complaining about the Android market.

So, why should they choose Android? And why should they choose your company if they do?

Here are some suggestions for ways that you can help:

• Switch to Android (temporarily, if you want). Get to know the platform. Understand why some people prefer it. Read some articles about purchasing habits of the users. Understand the differences between ios and android. Etc.
• Commit to Android as a platform. Talk openly at your company (and externally) about the market share, the benefits of the platform, and think about ways it can help your product – so that when an Android developer does join, he or she has some interesting projects to work on.
• Offer a signing bonus to developers who switch to Android for your company.
• Launch your next product on Android first (or at the same time as iOS).
• Attend Android meetups. Speak at Android meetups! Encourage the developers you work with to do the same.

These are basically 4 steps we need in order to accomplish the task:

1. Create a Paint using the PorterDuff.Mode.DST_OUT as Xfermode
2. Create a RadialGradient and assign to our Paint object as a Shader
3. Alter the gradient matrix using the setLocalMatrix method.
4. Use canvas.saveLayer when drawing

1. Paint using PorterDuff.Mode.DST_OUT

This is needed in order to draw an “hole” in our back background.

paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));

2. Create the RadialGradient shader:

This is required in order to draw a radial gradient “hole” in our black background. Thus revealing the background image using a “vignette” filter.

final int[] colors = new int[]{0xff000000, 0xff000000, 0};
final float[] anchors = new float[]{0, 0.5f, 1};
Shader shader = new android.graphics.RadialGradient(0, 0, 1, colors, anchors, Shader.TileMode.CLAMP);
paint.setShader(shader);

3. Alter the gradient matrix

The again, in order to create a real vignette effect we need to draw a custom “oval”, otherwise the result of draw something using the radialgradient shader will result in a simple circle. Instead, if we alter its matrix we can modify its aspect ratio, giving it the oval shape:

Matrix matrix = new Matrix();
matrix.postTranslate(rect.centerX(), rect.centerY());
matrix.postScale(rect.width() / 2, rect.height() / 2, rect.centerX(), rect.centerY());
shader.setLocalMatrix(matrix);

4. Draw on a canvas

Now we need to draw our objects on a real canvas. We need to save the current layer using Canvas.saveLayer because otherwise everything we previously drawn will be erased by our paint. But because we’re using saveLayer, we actually are drawing on an offscreen bitmap.

// save current status
// 'pBitmapRect' is the current Bitmap rectangle
canvas.saveLayer(pBitmapRect, mPaint, Canvas.ALL_SAVE_FLAG);
// draw the black background
canvas.drawRect(pBitmapRect, mBlackPaint);
// draw the vignette on the black background using our radial gradient
canvas.drawOval(tempRect2, mPaintShader);
canvas.restore();

Source Code

You can download the complete source code here:
https://github.com/sephiroth74/vignette_demo

In the same way I’ve created this library, with some more customization options, like the gravity and direction of the floating menu items.

Here’s a video of a sample implementation:

Source code and documentation can be find on the github project page:

https://github.com/sephiroth74/android-floating-action-menu

The fun thing is that it seems that they are aware of the problem and in fact they’re trying to use a workaround internally in the chromium source code.
For instance, this is the first workaround I found:
https://codereview.chromium.org/180273005/patch/80001/90003

which is basically looking into the “/data/app-lib/{packagename}-1/” folder for the missing libraries.
And in fact, inside the comments of that file you can read this:

Native library directory in an updated package is a symbolic link
to a directory in /data/app-lib/, for example:
/data/data/com.android.chrome/lib -> /data/app-lib/com.android.chrome[-1].
When updating the application, the PackageManager create a new directory,
e.g., /data/app-lib/com.android.chrome-2, and remove the old symlink and
recreate one to the new directory. However, on some devices (e.g. Sony Xperia),
the old directory was deleted, but deleting the old symlink failed,
and that makes system loading library from the /system/lib directory.

Then I noticed another approach which is probably better: http://goo.gl/cbCAmC

which is basically doing what the PackageManager was supposed to do, unzip the shared libraries from the apk file to the “lib” dir of the application itself.

Btw, I’m gonna try both of them and verify if they actually work so I can finally stop seeing that annoying bug in the Google Play Console!

Delay

Added withDelay(long ms) method in the RequestCreator class. Basically it will delay the load of the passed resource by n milliseconds.

[cce]
Picasso.with( context )
.load( url )
.withDelay( 100 )
.into( image );
[/cce]

Batch toggle on/off

In the original Picasso code all the “complete” events are dispatched using a batch operation, this means that you can have at the same time 3/4 “complete” events being triggered, which eventually can cause lags in the UI.
In this fork the batch is disabled by default and can be re-enabled by using:

[cce]
Picasso.with( context )
.setUseBatch( true );
[/cce]

Fork or download the source from GitHub:
https://github.com/sephiroth74/picasso

Link the library in your build.gradle:
compile “it.sephiroth.android.library.picasso:picasso:+”

You can find a better explanation of the project here: http://square.github.io/picasso/

By the way, long story short, as often happens, when you start to use a 3rd party library you also find it’s limitations and you want to make your own changes to fit your particular needs. In fact I made a fork of this library starting adding my changes.

Here’s a first list of changes I made:

Cache

Added the possibility to use an external cache instance per request.
Example:

[cce]// creating a cache object with 1MB max size
Cache cache = new LruCache( 1024*1024*1 );

// now create a new request which will use this cache object
Picasso.with( this ).load( file ).withCache( myCache ).into( imageView );[/cce]

Remember to clear the cache when you don’t need that anymore ( using cache.clear() )

Generators

Generators can be used to load images which cannot be loaded using the common scheme convention. There are different situations when you need to generate a Bitmap which is not directly related to a file or url or even a real bitmap resource.

In this case you can use the scheme “custom.resource” with a Generator.
A Generator is a simple interface with only one method:

[cce]public interface Generator {
Bitmap decode( String path ) throws IOException;
}[/cce]

So you can use a generator in this way:

[cce]Picasso.with(this)
.load( Uri.parse( “custom.resource://” + file ) )
.withGenerator( new Generator() {
@Override
public Bitmap decode( String path ) throws IOException {
return whatever(path);
}
} ).into( imageView );
[/cce]

Resize

Both the original Picasso methods resize and resizeDimen have been modified in the followings new methods:

[cce]public RequestCreator resizeDimen(int targetWidthResId, int targetHeightResId, boolean onlyIfBigger);
public RequestCreator resize(int targetWidth, int targetHeight, boolean onlyIfBigger);[/cce]

basically you can pass an option to skip the resize operation if the loaded bitmap is smaller than the passed `targetWidth` and `targetHeight`

BitmapFactory.Options

Picasso uses a default BitmapFactory.Options object, every time, to decode the required Bitmap.

I’ve added a method `withOptions` in the RequestCreator which allow you to pass your own Options object which will be used to decode the image.
Example:

[cce]BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Config.RGB_565;

Picasso.with(this)
.load(file)
.withOptions(options)
.into(imageView);
[/cce]

https://github.com/sephiroth74/picasso

[cce]public static final <T> T getFieldFromStyleable( Context context, String name ) {
try {
// use reflection to access the resource class
Field field = Class.forName( context.getPackageName() + “.R$styleable” ).getField( name );
if ( null != field ) {
return (T) field.get( null );
}
} catch ( Throwable t ) {
t.printStackTrace();
}
return null;
}[/cce]

Which can be used in this way:
[cce]int[] array = getFieldFromStyleable( context, “MyListView” );
array = context.obtainStyledAttributes( attrs, styleableArray, defStyle, 0 );[/cce]

Here’s the link to the project: https://github.com/sephiroth74/purePDF