-
Notifications
You must be signed in to change notification settings - Fork 2
Daily stand up summaries
No standups the last two days. The 11th was used watching the other groups' presentations about their summer projects as well as presenting our own. The 12th was spent fixing some minor bugs, getting the release version of the Android app to work again by properly embedding the AndroidManifest as well as preparing and performing a presentation for the local office.
Android's enable/disable now works without occasional bugs, loading screen has been added after application has authed before widgets are shown. New platform added: iPad. (Almost done). Pivot control on WP7 has a bug where databinding contents of pivot control did not work properly making enabling/disabling not work properly. This is fixed by instantiating the pivot control anew every time the contents change. In desktop/server Smeedee the upgrade to NHibernate 3 is complete and only lacks testing of the installer before it's pushed back to Stavanger's branch.
General work on all three platforms based on our continously updated "TODO before sprint" document:
iPhone: Lots of UI Tweaks: Application Icon, home screen widget added, heading is now regular fill and orange. New WP7-like design of TopCommitters bars. Android: User pictures added. Validation message when authing in settings fixed, Default Smeedee Url and key added, About screen removed, Smeedee home widget is only shown if no other widgets are enabled +++ WP7: Stability fixes, exception handling etc. Homescreen hidden when other widgets are enabled. Tombstoning added (state maintenance. similar to onResume on android.
The iPhone application is considered pretty much shippable now, after having recieved a couple of fixes. Mainly it no longer instantiates all the widgets anew after settings changes. This leads to a side effect where the user manually has to refresh widgets after changing settings. A more elegant solution for this will be sought after today.
The WP7 application now performs dynamic loading of widgets, the login screen is done. Some UI polishing has been done. And the presentation part of the application is fairly good.
There have been some problems with services not working during our dogfooding last week, which was tracked down to OutOfMemoryExceptions on the server after the standup. This should probably be fixed by optimizing data handling on the server, but for now we might try giving the virtual machine a bit more memory.
After the standup we had a meeting prioritizing remaining tasks, bugs, and regressions that should be fixed during the last week. A google document has been shared with all members of the team for continous editing during the week.
The widgets themselves are now all shippable. Yesterday we fixed the bar issue in top committers. The load more button in latest commits still isn't quite what we wanted it to be, but at least it works as it is now. We'll let this be as it is until we know we have more time. We've extracted the widget views into their own classes, so that we can dynamically add and remove them from the screen. The MainViewModel contains a databound list of views that controls which views are shown. It also contains databound properties can be set to toggle between showing widgets and settings. We've inserted an application bar at the bottom that controls this. It also contains the refresh button, which also works now.
Today work will continue with implementing the Login screen (that shows on first app load), and the login settings screen (available under the settings button). Hopefully we'll be able to reuse code between these. We'll also work on getting the enabled/disabled widgets system to actually do something (we currently only have the UI). If these two get done by today (likely), we'll begin work on implementing widget specific settings.
Yesterday we polished all of the UIs for WP7, and started using live data. We implemented the key value store for WP7, and an image loading mechanism. Build Status and Working Days Left are looking nice, while there are two issues from yesterday that we need to continue to work on today: In the Top Committers widget we need to implement the bars showing the proportion of commits for each committer, and in the Latest Commits widget we have a bug where the load more button sometimes fails to reappear after it is clicked the first time. We also don't have any place to enter login details yet, so we need to implement that, and make it accessible from the application bar (bottom of the screen).
We've discussed image caching a bit. We initially wanted to cache all loaded image to disk, so that they are not reloaded every time the app is launched. The code for this is in place, but we haven't implemented a way of invalidating this cache, so the images are cached forever. We're currently thinking that this functionality is of low priority, so we're just using the memory cache for now, which is emptied when the app is killed, and we'll have to see if we have time to implement disk cache invalidation when other more important issues have been fixed.
Yesterday, we started the first work on the WP7 version. It turned out to be very quick and easy to create UIs for this platform, so we had four minimal widget UIs up and running by the end of the day. On the iPhone, we worked on UI improvements and made sure all widgets are enabled by default.
Today, we'll work on improving the look of all WP7 widgets, starting to use real data instead of fakes, and implementing certain device specific services. We'll eventually need to implement IPersistenceService and IFileIO to get widgets to display real data. We also need to implement dynamic loading of widgets, a settings screen for this and a login screen.
We spent yesterday doing mostly UI and UX fixes, such as adding progress indicators where they're needed, and generally giving feedback when the user takes some action. The one thing missing feature wise at the moment is loading of images in top committers on Android.
There are still a number of small bugs and issues to be fixed on both platforms, but we need to prioritize in order to ship a WP7 app. Since Lars Melhus is going on a short vacation tomorrow, he'll spend today finishing up the iPhone app, and join the WP7 work when he gets back. The rest of us will start straight away on WP7, leaving android untouched as it is for the next few days. We've decided that widget specific settings are actually not all that useful, so we'll start off just implementing the widgets (with good default settings) for WP7.
Last Friday was the last day in the sprint, and was spent mostly on UI polish. On both platforms we've started work on showing activity indicators for when we're loading data. We're considering various options on how to implement this cleanly. On the iPhone, two widgets have gotten an inline settings view, for quick editing of certain settings. We've also worked on the CachedImageService, which will cache images loaded from the net, so we don't redownload them on every refresh.
On Android we do not currently load images, while on iPhone we load them directly from the net on every app load. The current issue with the CachedImageService is that it fails when the same cache file is accessed simultaneously (which happens frequently). We need to figure out a good way to get mutual exclusion on the cache file, without locking up the app.
Last day in this sprint, so today we need to have to shippable apps, one for Android and one for iPhone. The refresh button now appears if the widget has not been refreshed for the past 5 minutes, and the user can click the button and refresh the widget. Validation is now implemented fully, and works for all services, both on Android and iPhone. Image with cache service is being worked on for the Android version. Some widget polishing will be done on Android version today.
On iOS we now have all integration done with models and services, and pictures are now inplace on the iPhone. Also a lot of layout and design have been polished, so the iPhone app really starts getting nice.
The administration panel for mobiles in the smeedee desktop application is now finished, and we can generate user keys to distribute to the users that have the smeedee mobile application. The users then use that key to login to a smeedee server in the application. We will get the real validation service finish both on server and client side today. There is now a limit of number of commits that can be shown in the Latest Commits widget. The user can click a button "Load more" to see older commit messages, but no more than 40 commits can be loaded in total. Some cleanup here and there have been done on the Android version. Server url and user key settings in Global Settings have been changed so that the user gets feedback if the connection was either successfull or failed after new values has been passed in. A notification text (and maybe a button) is being made to notify the user if there has been a long time since the widget was refreshed. Work will continue with this feature today.
A login screen has been made on iOS, and polishing som widget design. Images (and caching of those) for different purposes will be added today, such as person images in top committers widget.
All services at the server side is now finished, and we are all ready to dump the fakservices and pass in the real services! We will go through all widgets and make sure they present a decent error message if the service is not working. We have started to work on an administration panel on the smeedee desktop application, to administer the mobile clients. What's needed there is an ability to generate keys for the mobile users.
On iOS we have made the topbanner on all widgets more stylish and added a refreshbutton (without any function yet). All settings for all widgets are now working, except the coloring of list items at Latest Commits settings, we will not prioritize this feature any high any more. Server url and user key settings are now in place, and we will reuse this work to create a login screen for the iOS today.
Integration with Build Status Service and Top Committers Service have been done and testet now, works smooth. We have configured the Smeedee Desktop Installer to include the mobile services and this has also been tested, works fine. Continuing today with the last real services for Latest Changeset and Working Days Left widget, to get real data from Smeedee, and in the end of this week remove all fake servies.
On iOS we have created nice custom section headers, and tweaked the layout of all configuration screens using a Style Extension class. The configuration screens looks okay for now, and can be tuned further in Sprint 3. Focus now is to implement the remaining functionality on iOS, and let the widgets use the real services in the end of this week.
We have decided to remove the setting where the user can show/hide username of who ran a build (Build Status Widget), because it makes little sense to have this opportunity on the mobile client. The usename is always shown. The mobile client is used on the go, and if one spots that a build is broken it's nice to have the opportunity to see who have caused this and alert the corresponding person about the issue.
Integration with the server side now works with csv data. Build Status widget recieves csv data (currently from http://folk.ntnu.no/dagolap/s/) with builds and shows'em in the Android widget. Top Committers widget has its server side implemented, but it seems like there are some problems connecting to it from the mobile client. We will continue with this integration today. Created a class ServiceConstants to be used for constants conserning url's for services and such.
On iOS we now have all settings screens for all widgets, but not all functionality is in place yet. We have also tried to make a common color and style theme for all screens at the iOS, but with no luck yet. We will continue the work today.
And Børge has come back from his holiday, ready to give it all the last three weeks!
Started working on integration now, but encountered some problems with Json libraries. They either dont work very well, or is not shared on all platforms. Started implementing very simple csv handling instead.
Lots of cleanup done in iPhone UI code, time to begin increasing functionality.
We pulled the latest version of Smeedee desktop from Stavanger and installed it on a server here. Works smooth (unlike the old laptop).
Lots of small fixes and refactoring were done yesterday. Moved code for storing and retrieving the enabled state of widgets into shared code (SmeedeeApp), which simplified both platforms, and implemented an event for IWidget to notify views on description changes, among other things. Not much left for Android, only a little tweaking on the "load more" functionality of latest commits.
The Iphone app still lacks functionality. We need a login dialog, and settings views for all the widgets. The settings part of the UI seems to have pretty bad design, that we will need to fix as well (hardcoded table cells for Url/Pass input, etc).
Most of the model code should now be finished. For today: In the latest commits widget we decided to implement a "load more" functionality, instead of loading a fixed number x. The header description causes some problems when the app starts. The container will call getdescription before the underlying model has loaded, causing inconsistencies between the list data and the description. This was previously "fixed" by adding an extra call to Refresh, but we need a more elegant solution.
The iPhone app is probably broken, we need to work on that as well.
Yesterday we found a very neat solution for the view switcher in java, which seems to work excellently after a direct port to C#. Some adjustments need to be made today, like triggering the update of the header when the view changes, the header size, and an issue where the view is slightly off after flipping the phone horizontal.
We have an issue where the login info settings would not be stored correctly, and so this will be addressed today. Also, some thought was given to how the model should behave when settings change. We decided that the model should contain all logic for keeping track of state and reloading, possibly with an event the view can listen to. This becomes an issue especially for the android platform, where settings can be changed without the model knowing right away. Anyway, it will be to task of the model to always present a consistent set of data, reloading when needed (or explicit calls to Load()).
Great. Hopefully the refactorings in the model will give us a better idea of exactly how the model interacts with the HTTP services. Once we have finished that part, we will know what HTTP services to implement on the server-side, and this can be done later this week. -Alex.
Considering iPhone app finished for sprint 1, we will not risk breaking the app on the device again after the bug we had on friday.
We have a memory leak problem in the Android app, where the ref count grows seemingly without bounds as we refresh the list models. Using events to update the top banner when we change widgets makes the problem even bigger. We also have an issue with color settings that does not work properly on 2.1. Today we will be focusing on the Android app, make small adjustments to make it ready for sprint 1.
All four iPhone widgets are now looking nice, and their main UIs are in a shippable state. Today we're moving on to implementing widget configuration and global configuration. We've decided on a UI for this, and will start with implementing that. In order to store these settings to the key-value store, we probably want to have a unified interface (IPersistenceService) to access it on both platforms. However, todays code will be iPhone specific so it's not strictly needed yet so the platform agnostic KV store won't be a priority today (we'll skip implementing it for now unless it makes us complete the settings faster).
On Android we've fixed the animation issue, so flicking between widgets now shows a smooth transition. We also had time to work on general improvements in code quality. There's one last bug that needs to be ironed out for the animation, where the wrong widget is displayed in the very first frame of the animation. The first priority on Android is to squash that bug, then we'll move on to new tasks (picking from the next sprint).
Great work! The iPhone app is in a great state. It looks even better on the device, which I will show you later today. Might be a good idea to skip a general/common framework for persistence due to the fact that we are so low on time (only a few hours before the end of the sprint). But we will need this if we expand to the Windows 7 Phone platform - and maybe even add more advanced config on the Android app. Anyway - awesome work. Looking forward to seeing the results at the end of the day. -Alex.
Yesterday we worked on flipping between widgets with a flick gesture. This is now possible, but we still have issues with the animation, which we will continue with today. On the iPhone we worked on the Latest Commits widget, and will continue today with styling this and perhaps other widgets. We're looking into how to best define global app-specific styles on the iPhone. Possibly we'll also get a version of Working days left up and running today.
We've discussed a remake of the IModelService interface. We had the following signatures:
IEnumerable<T> Get(IDictionary<string, string> args);
T GetSingle(IDictionary<string, string> args);
We'll remove this and exchange it with the following:
T Get();
T Get(IDictionary<string, string> args);
The methods no longer return an IEnumerable, and instead return a single object, that may or may not wrap an enumerable of model objects. This is motivated by several reasons. For instance The WorkingDaysLeft widget doesn't need an IEnumerable of anything. At the same time, TopCommitters needs extra metadata about the request, so it previously had to wrap a list of Committers inside a TopCommitters that was returned inside an IEnumerable. With the rewrite we'll avoid this.
On the Android side we've focused on clean up and fixes. We begun extracting colors and strings out of each view, in order to get a consistent look and feel. Extracting strings cleans up the code (and can allow us to do internationalization in the future). One important problem was that our service locator was taken away from us at runtime by Android (to clear up memory). This was fixed, and now we know that we can't in general share resources between Activities, and if we need to keep global state, it needs to be in SmeedeeApplication.
On the iPhone, we've got a simple version of the Latest Commits widget up and running. The only widget then that doesn't exist on the iPhone is the WorkingDaysLeft widget, which should be a quick job. The biggest issue with the Latest Commits widget was to fit commit messages of varying length and constant font size into the view, as this requires manual resizing of the UI components. This is now done, so what remains for this sprint is mainly to make the various widgets look better.
Last Friday we completed all the Android specific goals for this sprint, and most of us started working on the preference screens and UI polishing. For the preference screens, it turns out the built-in PreferenceScreen object is able to build these for us very easily. However, some work still needs to be done in the cases where we want to extend the standard UI-components, for instance when coloring the text in a color selection screen. All in all though, preference screens seem to be something we can complete faster than expected.
Today we will continue to work on preferences and UI polish, hooking the preferences up to the PersistenceService (to store and retrieve the settings). We've also started work on a scheme for refreshing data: Each widget will implement a specific refresh method, and a field expressing how often the widget wants to be refreshed. This also allows us to give the user a way to manually refresh each widget, while the UI and logic for this handled by the framework, not the widget.
Also: The mac has arrived!
Yesterday the TopCommitters model was redone according to our new policy of "the service does the logic of fetching and converting to domain model", and the UI will get some finishing touches today. Global settings have been largely implemented, and can now be used to change server/password token as well as viewing all available widgets. Today implementation of the checkboxes that selects enabled widgets will be worked on. Yesterday some work on the top banner was done, but after a small meeting after the stand up we decided on a look we wanted and will implement that today or later. Latest commits widget was pretty much done yesterday and now shows a nice red "missing comment" when required, and has beautified "x numbers ago" timestamping.
Architecture wise we decided that we want the models to adhere to SRP and not do any loading from external sources. Thus the models will only contain data and perform logic that is directly related to those data. Our integration services have been interfaced to return either an IEnumerable or a single IModel instance.
Yesterday we finished the login UI complete with validation of input fields. The latest commits widget and top commiters widget UI was started and the model for working days left was finished. Global settings are pretty much done and is now showing all widgets available and information based on the widget class attributes.
A general widget attribute model was created that is used to represent static widget information such as name and icon. Also a "bootstrapper"/main activity was created that decide where to take us next based on whether we have filled in server information, have configured widgets etc.
Things are coming together nicely!
Yesterday a global menu with two sub menus were created. A working day left widget has also been made which now looks fairly good, and some work has been done on the model. Today this might be completed, and work on its settings-view or another widget can be started. We also created a simple IoC container to store dependencies in a central place. Today we'll get started on the build status widget, the login screen and perhaps a global theme that will style all buttons and other ui components in Smeedee.
Great work! I like the fact that we are starting the widgets early. Keep it up! -Alex.
We now have an API for data storage and a serializer that will be able to store any object as a json string (later on that day we discovered that the json serialization could not be done on mobile devices and needs to be fixed). We also have a working slideshow where we can put widgets and switch between them based on time or using buttons.
The JSON serializer/storage work was still valuable: we have learned many lessons from it. We also "failed fast" here and didn't lose much time (I have lost weeks of work in other projects where I didn't fail fast enough). Sounds like a great start to some important parts of the UI were done today too. -Alex.
Friday was spent doing sprint planning and getting dynamic widget loading using reflection. Smeedee is up and running in the office and today we'll break the user stories into smaller tasks and start coding.
Great! It is important to build up the backlog at this early stage of the project, and have Smeedee desktop up and running on a big screen - so we can be reminded of what it is we are actually working for. -Alex.
Today we finished off some mockups of the widgets and the UI. Me and Dag Olav also ironed out some issues involving sharing projects between Visual Studio and MonoDevelop. In the afternoon we worked on dynamically loading widgets by scanning through the compiled assemblies.
This week, people have been learning the technologies such as git, Mono for Android, and Async programming with C#. Some RSS Reader apps were built by the students (in groups of two) to "warm them up". Today they were demo'd to each other. In the afternoon we are creating the backlog, and planning Sprint 1.