Join Xamarin at Microsoft Ignite in Chicago, IL from May 4-7, 2015. Key members from the Xamarin team will be available to answer your questions, discuss your apps and projects, and show you what’s new across our products. James Montemagno, Xamarin Developer Evangelist, will be delivering two talks this year: Go Mobile with C#, Visual […]
Android developers have been flocking to Material Design since its introduction with the release of Android Lollipop. With the recent update to the Support v7 AppCompat library it has never been easier to add Material Design to target older Android operating systems. Material Design is much more than just the core theming and styling that […]
Crédito Agrícola, one of the largest banks in Portugal, serves more than 1.2 million customers across 700 locations. In order to better support their increasingly mobile customer base, the bank created consumer banking apps for three mobile operating systems in the platform-specific languages. The costs of maintaining three separate teams and code bases quickly added […]
The post Crédito Agrícola Banks on Xamarin Platform, Test Cloud, and Insights appeared first on Xamarin Blog.
We’re working with our partners and community to bring full day mobile development events to a town near you with Xamarin Dev Days. What are Dev Days? Xamarin Dev Days are an intense, hands-on learning experience. More than just your average hackathon, they are free, day-long community events focused around learning how to build native iOS, Android, and […]
One thing I miss in iOS, which Android has, is auto expanding labels (and other views). Android has the
wrap_content layout option, which works really well to flow a view.
<LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="horizontal"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/currency_symbol" android:textAppearance="@style/TextAppearance.AppCompat.Large" android:textColor="@android:color/darker_gray"/>
iOS was lacking that – or so I thought. In the past, I’d had to use code to measure the size of a block of text, then set the frame and adjust other things.
var size = new NSString("Text here").StringSize(font, 9999, UILineBreakMode.CharacterWrap); label.Frame = new CGRect(label.Frame.Origin, size);
Autolayout changes things a bit. It’s all declarative-y and designer-y, so I prefer to keep things like that inside the storyboard designer as much as possible. I recently learned how to do this, tho: the >= (or <=) constraint.
In this case, I want the stop identifier (WW) to resize based on it’s content. It could be blank, or it could have one or 2 letters. I’m using the size of WW – about the maximum width – as the largest size, and allowing it to resize as needed. All the other constraints which are dependant on it flow from there.
The only constraint I need to manually adjust is the space between the WW and the following label (“7” in the image – “75m North West”), as I want to remove it – set it to zero – if the stop id is blank.
This works for vertical height too. Set it to be
greater than or equal to the minimum height – usually one line of text, which is around 21 points – and set the
number of lines to zero. The label will now take as much vertical space as needed.
This is not something which is obvious, at least it wasn’t to me, but it solves one of the big blockers I had with both Autolayout, and iOS in general – dynamic layout, especially of text.
As I described in a previous serie of post, vector drawables (and their animated counterparts) are one of the most powerful new visual elements introduced with Lollipop (and soon as a support lib it seems).
In this post, I’m gonna show you how we can achieve the following transition animation by solely using vector drawables and Android’s built-in widget state tracking mechanism:
To build an animation like this, you have to prepare the adequate stage. Afterwards, it’s just a matter of moving each individual pieces of that stage when needed.
In the above video, we can split the final visual in a couple of different parts.
Some like the center dot and the upper-half donut are static pieces, they never move. The two white thin rectangles, symbolizing the hands on a watch, are individual moving parts. The sun, moon and exclamation mark symbols are the varying state of the visual depending on the input.
Now, that’s only the visible part of the puzzle. If you look closely at the animation you can notice that everytime there is a state transition the right hand seems to be erasing the visible time symbol before the new one fade in.
This is where things get interesting because to be able to achieve this effect you have to get creative with the Z-ordering of your stage.
To understand this better, below is a rendering of all the layers of the visual:
The rectangle you see covering the half-bottom part of the picture is not an artifact. It’s painted with the same color than the overall window background thus acting as a cheap but effective hiding mask.
If I conceal this rectangle, here is what’s lurking behind: the other half of the visible top donut
To create the aformentioned effect, we will be moving that half-bottom donut to cover the top one, synchronizing it with the right clock hand. When not in use, it will be safely tucked behind our hiding rectangle.
Because vector drawables have a simple bottom to top drawing hierarchy, for this to work correctly we have declare pieces in a specific order:
- top half donut
- the 3 time symbols
- bottom half donut
- hiding rectangle
- the 2 hands white rectangle
Based on our animation needs, we then split this further into actual vector drawable
<group /> elements to arrive at the following shape (path data removed for brevity, you can download all the XML pack at the end of the article):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
State tracking widget
Before we dwelve into some more animation tricks, we first need to investigate how to make widget to represent our triple state because there is nothing in the default framework that allow this.
The good news is that, as I showed in a previous blog, it’s very easy to create a custom, state-aware widget which is what we are going to do with this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
By setting our state transition drawable as the background of this view, it will automatically react to state changes and animate accordingly. Using the normal state tracking mechanism also means that interruption mid-animations are gracefully handled for us.
One more trick
At this stage, I won’t go over every details of the individual animation definitions, they all tweak standard things like alpha and rotation on each piece of our stage. Nonetheless, you can read my animated vector drawable entry for more details on how they work.
I will only show a little trick that is useful when setting up more complex stages like this: zero-duration animators.
Take the following example that animates the bottom-half donut (to create the progressive hiding effect):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
The idea is that right after we have covered the entire upper-half, we want to immediately tuck it back under our hiding rectangle. This is because we then fade-in the new time symbol which would be hidden too otherwise.
Using zero-duration animators allow you to do just that by applying direct values to animated properties. The fact that there is a from attribute doesn’t matter much but since those properties are write only it will prevent object animator from complaining about missing accessors.
I use this in a couple of places to reset the stage state (since vector drawable instances are reused across transitions), quickly move away elements or hide them from view when they are not useful anymore.
You can download the XML definitions and widget source here.
Bug alert: there is currently a parsing bug where the animated vector drawable inflater will greedily read the entire document given to it. This causes an issue if you declare them inline in your animated state transition XML file because it will corrupt your entire state by reading everything instead of stopping at its corresponding end tag. The workaround is to always declare them in their own XML files like I did.