Mitul Nakum

Scaling a Django web application using caching and load balancing techniques.

noreply@blogger.com (Mitul Nakum) — Tue, 17 Jan 2023 08:38:00 +0000

Scaling a Django web application can be necessary as the number of users and requests to the application increases. Caching and load balancing are two techniques that can be used to improve the performance and scalability of a Django application.

1. Caching: Caching is a technique that stores frequently accessed data in a temporary location, such as memory or disk, so that it can be quickly retrieved without having to be recalculated or fetched from the database. There are several caching options available for Django, including:

File-based caching
Memory-based caching
Database caching
Memcached
Redis

2. Load balancing: Load balancing is a technique that distributes incoming requests among multiple servers to ensure that no single server is overwhelmed. Load balancing can be achieved using hardware or software load balancers. Some popular options for load balancing include:

HAProxy
Nginx
AWS Elastic Load Balancer
Google Cloud Load Balancer

To implement caching and load balancing, you can configure the web server(s) and the cache server(s) separately and then point your application to the appropriate servers. You can also use a managed service like AWS Elasticache, Azure Cache for Redis or Google Cloud Memorystore to handle caching, and use a managed load balancer service like AWS Elastic Load Balancer or Google Cloud Load Balancer.

It's worth noting that caching and load balancing are not mutually exclusive, you can use both at the same time, and you can use them together to improve the performance of your application.

You can also use caching to cache the results of some expensive operation or to cache the whole page to reduce the load on the server and the database, this can be done by using a caching framework like django-cacheops or django-cache-memoize.

Also, keep in mind that caching and load balancing are not silver bullets, it's important to monitor your application and make sure that it's performing well and identify bottlenecks and improve them.

Mitul Nakum - Linkedin

Mitul Nakum - StackOverflow

Mitul Nakum - Twitter

Using Django Signals to automate certain actions in the application.

noreply@blogger.com (Mitul Nakum) — Mon, 16 Jan 2023 06:33:00 +0000

Django signals allow you to automate certain actions in your application by "listening" for specific events, such as a user being created or a model being saved, and then triggering a corresponding action.

Here are the steps to use Django signals in your application:

1. Define a signal in your app's signals.py file, using the 'django.dispatch.Signal' class. For example:

from django.dispatch import Signal

user_created = Signal(providing_args=["user"])

2. Connect a receiver function to the signal in the app's ready() method or at any other point of the code. A receiver function is a function that will be executed when the signal is emitted. For example:

from django.contrib.auth.models import User

from .signals import user_created

def create_profile(sender, **kwargs):

user = kwargs["user"]

Profile.objects.create(user=user)

user_created.connect(create_profile, sender=User)

3. Emit the signal in the appropriate place in your code. For example:

from django.contrib.auth.models import User

from .signals import user_created

user = User.objects.create_user(username="johndoe", email="johndoe@example.com", password="password")

user_created.send(sender=User, user=user)

It's important to keep in mind that signals are a way to decouple the different components of your app, since the sender and the receiver don't need to know each other in order to interact, this is one of the ways to handle cross-cutting concerns

It's also worth noting that you can use signals to handle other actions such as sending an email when a user is created, logging when a certain action happens, and more.

Keep in mind also that you can use signals to handle pre_save and post_save, pre_delete and post_delete, and more, this way you can handle the data before or after it is saved to the DB.

Mitul Nakum - Linkedin

Mitul Nakum - StackOverflow

Building a RESTful API using Python-Django REST framework.

noreply@blogger.com (Mitul Nakum) — Fri, 13 Jan 2023 12:16:00 +0000

Building a RESTful API using Django REST framework is a great way to create a powerful, flexible API for your web application.

Here are the steps to build a RESTful API using Django REST framework:

Install the Django REST framework by running pip install djangorestframework.
Add 'rest_framework' to your INSTALLED_APPS list in the settings.py file.
Create a new Django app for your API or add the API functionality to an existing app.
Define your models for the API data.
Create serializers for your models using the Django REST framework serializers.
Create views for your API using the Django REST framework views or viewsets.
Define your API URLs using the Django REST framework routers.
Test your API using the Django REST framework test client or by making HTTP requests to the API endpoints with a tool like Postman.

Django REST framework provides many useful features like authentication, permissions, pagination, and serialization out of the box. You can also customize the API views and serializers to fit the specific needs of your application.

It's also good to note that the framework provides different types of views, like viewsets and generic views, that handle the basic CRUD operations and allow to you customize the behavior of the API.

It's also important to keep in mind that RESTful APIs should be designed to adhere to the principles of REST (Representational State Transfer) and HTTP protocol, including the use of appropriate HTTP status codes, and the use of proper HTTP methods (like GET, POST, PUT, DELETE) for the CRUD operations.

It is a great tool to use when you want to expose a data model or a subset of it over the web, it is also good for creating an interface for third-party apps to interact with your app.

Creating a custom user model in Python-Django to extend the functionality of the built-in user model

noreply@blogger.com (Mitul Nakum) — Thu, 12 Jan 2023 05:20:00 +0000

Creating a custom user model in Django allows you to extend the functionality of the built-in user model and add additional fields or methods to it. This can be useful for adding extra information about the user or for customizing the authentication process.

Here are the steps to create a custom user model in Django:

Create a new model that inherits from the built-in AbstractBaseUser or AbstractUser classes.

You can add any additional fields you need to this model.

Create a custom manager for the new model that inherits from BaseUserManager or UserManager.

Set the AUTH_USER_MODEL setting in your Django project's settings.py file to the custom user model.

Create a custom form that inherits from the built-in forms.UserCreationForm or forms.UserChangeForm and adjust it to work with the custom user model.

Add to your custom manager the functions like create_user,create_superuser, etc.. that are used to create the new user in the DB

Update the views and templates to use the custom form and custom user model.

It's important to note that after changing the User model, the data may not be retrieved from the database in the case of ManyToMany fields, so you need to run the command python manage.py makemigrations --empty to create an empty migration file and modify it to specify how the data should be handled.

It's worth noting that this is more advanced customisation and more care should be taken to ensure that the custom user model behaves as expected in all cases. It's always recommended to have a backup of the data and test thoroughly.

Alternatives to django-crontab

noreply@blogger.com (Mitul Nakum) — Wed, 11 Jan 2023 13:15:00 +0000

There are several alternatives to django-crontab that can be used to schedule tasks in a Django application. Some popular options include:

Celery: A distributed task queue that can be used to schedule tasks in a Django application. Celery supports various types of backends for storing task results and schedule information, such as Redis, RabbitMQ, and SQLAlchemy.

Schedule: A lightweight library for scheduling tasks in Python. Schedule supports in-process scheduling, which can be useful for running tasks within a Django application.

APScheduler: A lightweight, in-process task scheduler that can be used to schedule tasks in a Django application. It supports scheduling tasks at specific intervals (e.g., every 10 minutes) or at specific times (e.g., 3:00 PM on the first day of the month).

django-background-tasks: is a database-backed work queue for Django, it allows you to run Python functions asynchronously.

All of these are mature and widely used in the Python community, your choice will depend on your specific use case and requirements.

Options for scheduling tasks in a Django application

noreply@blogger.com (Mitul Nakum) — Wed, 11 Jan 2023 12:55:00 +0000

There are several options for scheduling tasks in a Django application, including:

Celery: A distributed task queue that can be used to schedule tasks to run asynchronously in the background. It supports various types of backends for storing task results and schedule information, such as Redis, RabbitMQ, and SQLAlchemy.

Schedule: A lightweight library for scheduling tasks in Python. Schedule supports in-process scheduling, which can be useful for running tasks within a Django application.

django-background-tasks: is a database-backed work queue for Django, it allows you to run Python functions asynchronously.

Django management commands: Django includes a built-in mechanism for running custom management commands, which can be scheduled using cron, Windows Task Scheduler, or other similar tools.

Summary

All of these options have their own pros and cons, and the best choice for your application will depend on your specific use case and requirements. But if you want to schedule tasks in a more simplified way and without a need for an external message broker celery might not be the best fit, Scheduling library or APScheduler could be a better option.

Common Bugs When Testing iOS Apps

noreply@blogger.com (Mitul Nakum) — Mon, 03 Mar 2014 06:15:00 +0000

The bugs we’ve encountered ranged from app specific usability issues to general issues common amongst many apps. Today, we want to highlight 5 issues that we’ve encountered repeatedly, using some of the most popular apps as examples. The list below is presented in no particular order.

1. Handling Bad Network Connections

iOS devices are inherently mobile, so apps cannot assume permanent, fast connections to the internet. Tasks requiring network connections should generally be asynchronous and notify the user if they fail due to lack of connectivity. Facebook Messenger and iOS FaceTime handles this nicely.

In Facebook Messenger, a warning message is displayed prominently, indicating that Internet connection is required for the app to function.

In FaceTime, an alert is displayed with buttons that take the user directly to network settings.

On the other hand, Vine and Instagram do not handle this well.

In Vine, users see a sad face and posts simply do not load. There’s no indication that this is caused by network connectivity.

Instagram shows a large reload button on images that cannot load. This button has no effect while network is off.

2. Handling Chinese (extended) Keyboard

iOS has a number of international keyboards built in. While most of these keyboards are of the same size, a few keyboards have extended sections. The Chinese Pinyin keyboard is an example of the extended keyboard. Apps should not assume a fixed keyboard size and should adjust their content appropriately.

The Google+ app, as shown above, has a small button above the normal keyboard that hides the keyboard when pressed.

However, when the Chinese keyboard is used, the extended keyboard covers most of the button, rendering it useless.

Using the device in landscape mode exacerbates the problem. In Twitter, the extended keyboard, custom buttons, navigation bar, and status bar combined take up almost the entire screen, leaving no room to display the input text field.

3. Handling Privacy Settings

iOS privacy settings control third party app access to photos, locations, and contacts. Apps needing access to these assets need to handle cases when access has been denied either inside the app or outside through system settings. A great way to handle this is to let the users know about the necessary permissions and give them instructions on how to turn them on.

A good example of how to handle this is the Facebook app. When it lacks permission to access location, it shows a clear message with step-by-step instructions for users on how to grant access.

On the other hand, when Vine lacks permission to access location, it gets stuck searching for nearby places with no indication of what’s wrong.

4. Validating User Input

Many apps allow users to input username, birthdate, or other account information. Basic input validation should be implemented, and if the user’s input is invalid, a clear explanation should be presented.

Skype does not validate user’s birthdate, so a completely bogus date can be entered.

Path has very few restrictions for usernames. In the screenshot above, the username is set to a large number of blank spaces followed by a period. Path does not allow usernames to contain only blank spaces and will fail silently (i.e. it does not save the username and shows no explanation).

5. Handling Simultaneous Button Presses

iOS devices support multi-touch and apps should properly handle cases when users intentionally or accidentally touch multiple buttons at the same time.

In Pinterest, tapping ‘Pin it’ and ‘Send’ at the same time when viewing a pin will cause the app to enter a bad state.

Conclusion

As we’ve illustrated above, common issues can be found even in some of the most popular and mature apps. By sharing experiences we gained from testing, we hope to help improve apps built by our readers. There’s a lot more we’d like to share in future posts. If you have any thoughts or questions regarding testing, don’t hesitate to contact us at support@rultech.com

Rultech Blog - Wordpress

Rultech Blog - Blogspot

Rultech Knowledge Base - Knowledge Base

Pro!deaClub Blog - Blog

Pro!deaClub - Blogspot

Usefull Plugins for Xcode

noreply@blogger.com (Mitul Nakum) — Sun, 23 Feb 2014 05:11:00 +0000

What’s this all about?

This is just a short collection of some useful Xcode 4/5 plugins I use. Most of us Cocoa developers, I guess, are looking about for making our development environment a more friendly and “warm” place with features enriching the development experience.

This list is far off being complete and will be extended permanently. So if you like it you should take a look at it from time to time.

UncrustifyX

Xcode plugin to uncrustify the source code opened in the editor.
UncrustifyX Github-Repository.

XCFixins

This project includes plugins (known as fixins) that extend Xcode and fix some of its annoying behaviors.
XCFixins Github-Repository.

Xcode_beginning_of_line

XCode 4 plugin to make HOME key jump to the first non-whitespace line of code.
Xcode_beginning_of_line Of Line Github-Repository.

Dash Plugin for Xcode

This plugin allows you to use Dash (I think, this is a Must-Have!) instead of Xcode’s own documentation viewer when using option-click (or the equivalent keyboard shortcut) to view the documentation for the selected symbol.
Dash Plugin Github-Repository.

Exterminator

A magic button in Xcode to exterminate the current project’s DerivedData directories.
Exterminator Github-Repository.

KSImageNamed

Xcode plug-in that provides autocomplete for imageNamed: calls.
KSImageNamed Github-Repository.

ColorSense

Plugin for Xcode to make working with colors more visual. Every time when place the cursor on a UIColor/NSColor code fragment it will show the current color of this code as an overlay. By clicking this color overlay you can edit the value just with the standard OS X color picker.

ColorSense Github-Repository.

Mini Xcode

This is a plugin that makes it easier to run Xcode without the main toolbar. It adds keyboard shortcuts for selecting the active scheme and device, and a compact popup menu in the window title bar that shows the currently selected run configuration.
Mini Xcode Github-Repository.

Lin

Xcode4 plugin showing completion for NSLocalizedString andlocalizedStringForKey:value:table:.
Lin Github-Repository.

XVim

XVim is a Vim plugin for Xcode. The plugin intends to offer a compelling Vim experience without the need to give up any Xcode features..
XVim Github-Repository.

Fuzzy Autocomplete for Xcode

A Xcode 5 plugin that adds more flexible autocompletion rather than just prefix-matching.
Please read also this very interesting article of the developer of this plugin about the way of reverse engineering Xcode with dtrace.
Fuzzy Autocomplete Github-Repository.

XToDo

A plugin to collect and list the TODO, FIXME, ???, !!!
XToDo Github-Repository.

ClangFormat

An Xcode plug-in to to use clang-format from in Xcode. With clang-format you can use Clang to format your code to styles such as LLVM, Google, Chromium, Mozilla, WebKit, or your own configuration.
ClangFormat Github-Repository.

VVDocumenter

Xcode plug-in which helps you write Javadoc style documents easier.
I use this plugin constantly!
VVDocumenter Github-Repository.

KFCocoaPodsPlugin

Xcode plug-in for CocoaPods with pod commands/console output, user notifications & code completion.
KFCocoaPodsPlugin Github-Repository.

Alcatraz

Alcatraz is an open-source package manager for Xcode 5. It lets you discover and install plugins, templates and color schemes without the need for manually cloning or copying files. It installs itself as a part of Xcode and it feels like home.
Alcatraz Github-Repository.

SCXcodeMiniMap

SCXcodeMiniMap is a plugin that adds a source editor MiniMap to Xcode.
SCXcodeMiniMap Github-Repository.

Rultech Blog - Wordpress

Rultech Blog - Blogspot

Rultech Knowledge Base - Knowledge Base

Pro!deaClub Blog - Blog

Pro!deaClub - Blogspot

Testing on Android : Unit Tests

noreply@blogger.com (Mitul Nakum) — Mon, 03 Feb 2014 10:57:00 +0000

JUnit Tests

There's no reason you can't use normal JUnit 4 testing for Android applications... as long as you stay away from anything Android.

Normally you compile against the SDK's android.jar, which contains nothing but stubbed methods that throw exceptions when run. When you actually upload your APK to a device, it uses the device's implementations of all those stubs. As a result, when running normal unit tests in your IDE, you get no access to those framework implementations (instead receiving mountains of exceptions). This is not a big deal if you're testing some simple functionality that doesn't touch Android itself.

Pros:

Fast and easy

Cons:

Cannot use any Android framework classes

The Android Testing Framework

The Android testing framework is the official method of unit testing on Android. It loads your application onto a device, then runs JUnit-based test suites. Since it runs on the actual OS you can use the Android framework as you normally would in your application and can conduct a series of realistic tests that way.

Ostensibly the testing framework is unit testing, but the slowness of having to fully compile and upload your app onto a device before executing any tests makes testing slow. Plus, you have to make sure you've got a device attached or an emulator running. As a result, I might consider the testing framework for semi-regular tests (e.g., whenever you push a new commit, or nightly tests) but I would have trouble using them while actively developing.

Pros:

Access to the Android framework

Cons:

Slow

Requires attached device or running emulator

Uses JUnit 3 (instead of the newer JUnit 4)

Robolectric

Robolectric is a project that unifies the speed of unit testing with the ability to access the Android framework. It does this by implementing all those stubs with mocked classes.

Having tried it out, it is lightning fast and works as expected. I'm also impressed with the amount of active development on it - this is a rapidly improving framework. However, the active development does take a toll; documentation is a bit lacking, plus some new versions of Robolectric break things in previous versions. Plus, it can't mock everything - for example, inter-app communication - since it's not on an actual Android OS. That said, the benefits here far outweigh the negatives when it comes to unit testing Android.

Pros:

Fast

Can access mocked Android framework

Actively developed

Cons:

Not the true Android framework

Not everything is mocked

Lacking documentation

Rultech Blog - Wordpress

Rultech Blog - Blogspot

Rultech Knowledge Base - Knowledge Base

Pro!deaClub Blog - Blog

Pro!deaClub - Blogspot

Mobile User Acquisition - A Basic Pathway

noreply@blogger.com (Mitul Nakum) — Mon, 27 Jan 2014 06:32:00 +0000

Acquiring users in a cost-efficient way is critical for building a successful app business and apart from time, skills and money you need to have a well-thought strategy in place that will enable you to iterate fast and learn from your mistakes.

In a previous post, we have constructed the mobile user acquisition funnel and by measuring the conversions at each step we are now ready to experiment with different optimizations and identify the ones that yield the best results.

Many users will be dropping-out at every step of your funnel and although on the surface this behavior appears to be random, you should try to understand its key drivers and take actions to minimize the drop-off.

To put things in perspective, think about a relatively expensive item you’ve purchased in the last 3 months. Then ask yourself the following questions:

Did you purchase that item because it was fulfilling one of your needs?
Was the shop you bought it from trustful?

Chances are that you responded positively to both questions. The same questions are, unsurprisingly, being asked by every potential user before deciding whether to download your free app or not and you should center your initial optimization efforts around them.

Funnel – Top

Getting more and more people at the top of your mobile user acquisition funnel is definitely a good thing, provided that your funnel is not leaky and you get a significant proportion of regular users at the other end.

A good strategy would be to first soft-launch so that you make sure you have healthy conversions at each step and then ramp up your efforts with a proper launch, to increase the number of people that will find out your app exists.

Currently, performance-based mobile marketing (paid or free with cross-promotion) is considered by many the biggest contributor to the growth of a mobile user base and can be complemented with growth hacks, traditional marketing and app store SEO that will eventually provide an incremental value. For paid non-incentivized app installs, a strategy to minimize costs is to buy inventory from a variety of mobile ad networks (since CPI prices can increase substantially when a mobile ad network saturates) and avoid peak hours or special events where inflated CPI prices are observed.

Some users will find out about your app through organic ways such as browsing categories in the app store, through lists of featured apps or by actively searching for it. Localization can be quite powerful and you should consider launching in different countries and app stores. At the same time a significant volume of organic downloads can be generated by achieving a high rank position (to get perspective, for the #1 iTunes App Store rank you need from 400,000 to 1,000,000 daily installs plus positive reviews) or getting featured, however, as the app stores dynamics and rankings change all the time you should plan your launch strategy assuming neither will happen.

If you want to amplify all the above marketing efforts and decrease substantially the acquisition cost, make sure you bake some growth hacks in your app i.e. an invitation system where your happy users can effortlessly invite some of their friends while getting an extra value in return. The virality factor (also known as the k-factor) is important because if, for example, you manage to get 1 out of 10 users to convince a friend to try your app (k-factor = 0.1), this means that for every 1000 users you acquire through whatever acquisition channel, another 100 users will be acquired at no extra cost.

Finally, referrals coming from influential bloggers, app review sites or even press releases will lower substantially the trust barrier you have to overcome and depending on the size of their audience, it could have a significant impact on growing your user base.

Funnel – Middle

If things go well from your efforts at the top of the funnel, some potential users will have already visited your app store page.

Your primary goal now is to convince them that your app is the best to fulfill their particular need and aim to quickly build trust.

At your disposal is every piece of information that can be tweaked and you should experiment with different variations in order to optimize conversions:

Copy: You need a catchy title that communicates clearly the need your app is addressing. Think hard about the layout of your app description, the actual words and how to nail the “above the fold” text. Ridiculously good-looking screenshots are a strong indicator of credibility and can build trust.
Social Proof: The volume and quality of your ratings and reviews, have an important role when building trust. Make sure that you swiftly address significant complaints and be prepared to fight the classic “chicken-and-egg” situation at the very beginning.
Price: Different business models, will affect conversion rates differently throughout the entire acquisition funnel. Know your strengths and the weaknesses of the competition, and position your app business accordingly.
Meta: The actual size of your app, the frequency of updates, its maturity content and the number of permissions it requires, will affect the conversions albeit at a lessened extend.

Funnel – Bottom

The download has finished in a timely manner and if he didn’t forget to open the app, you got yourself a new user.

Designing a flawless new user experience (NUX) is critical in the “all-or-nothing” battle that takes place the first time a new user opens your app. Deep-linking to a custom landing page within the app, easy on-boarding and giving them a reason to come back again should accompany your product design skills that are now being tested.

He decides to close the app and if he opens it again a few times more, give yourself a pat on the back – you got a regular user!

Optimization

It’s important to develop a process of constant experimentation, as some optimizations might work better than others over time and as your user base grows.

A useful tool for optimization is the concept of user lifetime value (LTV), where you estimate the maximum revenue you will ever get from an average user, and this is then used as the maximum threshold on how much you are willing to spend for acquiring a user.

Once your funnel conversions are healthy, you should aim to identify a handful traffic sources that bring high-LTV users at a low acquisition cost, and double-down your resources on them.

Rultech Blog - wordpress

Rultech Blog - blogspot

Rultech Knowledge Base

Pro!deaClub Blog

Pro!deaClub - blogspot

Way to create good User Interface Design

noreply@blogger.com (Mitul Nakum) — Sun, 19 Jan 2014 16:41:00 +0000

 Clarity is job #1

Clarity is the first and most important job of any interface. To be effective using an interface you've designed, people must be able to recognize what it is, care about why they would use it, understand what the interface is helping them interact with, predict what will happen when they use it, and then successfully interact with it. While there is room for mystery and delayed gratification in interfaces, there is no room for confusion. Clarity inspires confidence and leads to further use. One hundred clear screens is preferable to a single cluttered one.

 Interfaces exist to enable interaction

Interfaces exist to enable interaction between humans and our world. They can help clarify, illuminate, enable, show relationships, bring us together, pull us apart, manage our expectations, and give us access to services. The act of designing interfaces is not Art. Interfaces are not monuments unto themselves. Interfaces do a job and their effectiveness can be measured. They are not just utilitarian, however. The best interfaces can inspire, evoke, mystify, and intensify our relationship with the world.

 Conserve attention at all costs

We live in a world of interruption. It's hard to read in peace anymore without something trying to distract us and direct our attention elsewhere. Attention is precious. Don't litter the side of your applications with distractible material…remember why the screen exists in the first place. If someone is reading let them finish reading before showing that advertisement (if you must). Honor attention and not only will your readers be happier, your results will be better. When use is the primary goal, attention becomes the prerequisite. Conserve it at all costs.

 Keep users in control

Humans are most comfortable when they feel in control of themselves and their environment. Thoughtless software takes away that comfort by forcing people into unplanned interactions, confusing pathways, and surprising outcomes. Keep users in control by regularly surfacing system status, by describing causation (if you do this that will happen) and by giving insight into what to expect at every turn. Don't worry about stating the obvious…the obvious almost never is.

 Direct manipulation is best

The best interface is none at all, when we are able to directly manipulate the physical objects in our world. Since this is not always possible, and objects are increasingly informational, we create interfaces to help us interact with them. It is easy to add more layers than necessary to an interface, creating overly-wrought buttons, chrome, graphics, options, preferences, windows, attachments, and other cruft so that we end up manipulating UI elements instead of what's important. Instead, strive for that original goal of direct manipulation…design an interface with as little a footprint as possible, recognizing as much as possible natural human gestures. Ideally, the interface is so slight that the user has a feeling of direct manipulation with the object of their focus.

 One primary action per screen

Every screen we design should support a single action of real value to the person using it. This makes it easier to learn, easier to use, and easier to add to or build on when necessary. Screens that support two or more primary actions become confusing quickly. Like a written article should have a single, strong thesis, every screen we design should support a single, strong action that is its raison d'etre.

 Keep secondary actions secondary

Screens with a single primary action can have multiple secondary actions but they need to be kept secondary! The reason why your article exists isn't so that people can share it on Twitter…it exists for people to read and understand it. Keep secondary actions secondary by making them lighter weight visually or shown after the primary action has been achieved.

 Provide a natural next step

Very few interactions are meant to be the last, so thoughtfully design a next step for each interaction a person has with your interface. Anticipate what the next interaction should be and design to support it. Just as we like in human conversation, provide an opening for further interaction. Don't leave a person hanging because they've done what you want them to do…give them a natural next step that helps them further achieve their goals.

 Appearance follows behavior

Humans are most comfortable with things that behave the way we expect. Other people, animals, objects, software. When someone or something behaves consistently with our expectations we feel like we have a good relationship with it. To that end designed elements should look like how they behave. Form follows function. In practice this means that someone should be able to predict how an interface element will behave merely by looking at it. If it looks like a button it shouldact like a button. Don't get cute with the basics of interaction…keep your creativity for higher order concerns.

 Consistency matters

Following on the previous principle, screen elements should not appear consistent with each other unless they behave consistently with each other. Elements that behave the same should look the same. But it is just as important for unlike elements to appear unlike (be inconsistent) as it is for like elements to appear consistent. In an effort to be consistent novice designers often obscure important differences by using the same visual treatment (often to re-use code) when different visual treatment is appropriate.

 Strong visual hierarchies work best

A strong visual hierarchy is achieved when there is a clear viewing order to the visual elements on a screen. That is, when users view the same items in the same order every time. Weak visual hierarchies give little clue about where to rest one's gaze and end up feeling cluttered and confusing. In environments of great change it is hard to maintain a strong visual hierarchy because visual weight is relative: when everything is bold, nothing is bold. Should a single visually heavy element be added to a screen, the designer may need to reset the visual weight of all elements to once again achieve a strong hierarchy. Most people don't notice visual hierarchy but it is one of the easiest ways to strengthen (or weaken) a design.

 Smart organization reduces cognitive load

As John Maeda says in his book Simplicity, smart organization of screen elements can make the many appear as the few. This helps people understand your interface easier and more quickly, as you've illustrated the inherent relationships of content in your design. Group together like elements, show natural relationships by placement and orientation. By smartly organizing your content you make it less of a cognitive load on the user…who doesn't have to think about how elements are related because you've done it for them. Don't force the user to figure things out…show them by designing those relationships into your screens.

 Highlight, don't determine, with color

The color of physical things changes as light changes. In the full light of day we see a very different tree than one outlined against a sunset. As in the physical world, where color is a many-shaded thing, color should not determine much in an interface. It can help, be used for highlighting, be used to guide attention, but should not be the only differentiator of things. For long-reading or extended screen hours, use light or muted background colors, saving brighter hues for your accent colors. Of course there is a time for vibrant background colors as well, just be sure that it is appropriate for your audience.

 Progressive disclosure

Show only what is necessary on each screen. If people are making a choice, show enough information to allow them the choice, then dive into details on a subsequent screen. Avoid the tendency to over-explain or show everything all at once. When possible, defer decisions to subsequent screens by progressively disclosing information as necessary. This will keep your interactions more clear.

 Help people inline

In ideal interfaces, help is not necessary because the interface is learnable and usable. The step below this, reality, is one in which help is inline and contextual, available only when and where it is needed, hidden from view at all other times. Asking people to go to help and find an answer to their question puts the onus on them to know what they need. Instead build in help where it is needed…just make sure that it is out of the way of people who already know how to use your interface.

 A crucial moment: the zero state

The first time experience with an interface is crucial, yet often overlooked by designers. In order to best help our users get up to speed with our designs, it is best to design for the zero state, the state in which nothing has yet occurred. This state shouldn't be a blank canvas…it should provide direction and guidance for getting up to speed. Much of the friction of interaction is in that initial context…once people understand the rules they have a much higher likelihood of success.

 Great design is invisible

A curious property of great design is that it usually goes unnoticed by the people who use it. One reason for this is that if the design is successful the user can focus on their own goals and not the interface…when they complete their goal they are satisfied and do not need to reflect on the situation. As a designer this can be tough…as we receive less adulation when our designs are good. But great designers are content with a well-used design…and know that happy users are often silent.

 Build on other design disciplines

Visual and graphic design, typography, copywriting, information architecture and visualization…all of these disciplines are part of interface design. They can be touched upon or specialized in. Do not get into turf wars or look down on other disciplines: grab from them the aspects that help you do your work and push on. Pull in insights from seemingly unrelated disciplines as well…what can we learn from publishing, writing code, bookbinding, skateboarding, firefighting, karate?

 Interfaces exist to be used

As in most design disciplines, interface design is successful when people are using what you've designed. Like a beautiful chair that is uncomfortable to sit in, design has failed when people choose not to use it. Therefore, interface design can be as much about creating an environment for use as it is creating an artifact worth using. It is not enough for an interface to satisfy the ego of its designer: it must be used!

Rultech Blog - wordpress

Rultech Blog - blogspot

Rultech Knowledge Base

Pro!deaClub Blog

Pro!deaClub - blogspot

Fixing UITextView on iOS 7

noreply@blogger.com (Mitul Nakum) — Sun, 19 Jan 2014 16:14:00 +0000

UITextView on iOS 7 is a lot more powerful as Apple switched over from using WebKit to TextKit for rendering. It’s also very much a 1.0, and has some quite terrible bugs. It goes so far that people started writing replacements for the whole scrolling logic.

Of course people reported these issues in PSPDFKit as well, so I had to find a workaround. I’m usingcontentInset when the keyboard (iPhone) or another view (iPhone/iPad) goes up, which is pretty much completely ignored by UITextView in iOS 7. This is most frustrating since it works perfectly in iOS 6.

At first my solution was based on a category, but after discovering more and more needed hooks, I moved over to a subclass that automatically forwards all delegate methods. This has the advantage of more shared code, and we might be able to remove all those horrible hacks once iOS 8 comes out. I certainly hope so and will write a few more radars.

So, what’s fixed in PSPDFTextView?

When adding a newline, UITextView will now properly scroll down. Previously, you needed to add at least one character for this to happen.
Scrolling to the caret position now considers contentInset. UITextView completely ignored this.
Typing will also consider contentInset and will update the scroll position accordingly.
Pasted text will scroll to the caret position.

To enable these fixes, simply use PSPDFTextView instead of UITextView:

https://github.com/steipete/PSPDFTextView

This is working quite well for my use case, but there surely are edge cases where this won’t be enough (like when using rich text). I also tried using the new textContainerInset but this didn’t work as intended and didn’t solve my scrolling problems.

I have to give credit to countless people that searched for the same solution - this very much was a community oriented fix. Sadly, this doesn’t seem to be a priority for Apple, since it’s still broken in iOS 7.1b3.

Please fork the repo and send a pull request, if you have any ideas how to simplify the code or find an even better workaround.

Rultech Blog - wordpress

Rultech Blog - blogspot

Rultech Knowledge Base

Pro!deaClub Blog

Pro!deaClub - blogspot

Keyboard on iOS - Rultech Weekly

noreply@blogger.com (Mitul Nakum) — Sun, 05 Jan 2014 05:15:00 +0000

The keyboard is present in nearly every application out there. Using the keyboard is the easiest way to provide users with a way to input alphanumeric data into applications. Trivial as it might look like in the beginning, a correct implementation of keyboard behavior can be a costly endeavor. Multiple keyboard states make it hard to implement logic that will behave correctly for all of them.

This post will cover my observations and experiences with the keyboard system in iOS. I will try to describe some basic concepts behind the keyboard notification system and take a closer look at the order in which notifications are sent.

Keyboard System

There are two main patterns across the Objective-C/Cocoa framework that give the user an idea of how the communication process between different objects functions – the delegation pattern and the notifications pattern.

The public keyboard API is built around the latter. You just inform the NSNotificationCenterobject that you want to receive some specific notifications. These notifications are later sent to you from somewhere else within the application when a specific type of event occurs.

Given that notifications are a generic pattern, there has to be a way to utilize them so they provide as much information as we want them to. Moreover, this information can be represented by a different number of objects which can, in turn, represent various types. For this particular purpose there is auserInfo property in the NSNotification class. This dictionary provides the elements listening for notifications with an additional context behind the triggering of the notification.

For keyboard notifications, we use the [NSNotificationCenter defaultCenter] method to get an instance of NSNotificationCenter class, which will be used for the notification’s registration process.

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillShow:) name:UIKeyboardWillShowNotification object:nil];

And that’s all you need to start receiving notifications about the appearance of the keyboard. Well, what next?

Keyboard’s Notification

To put things bluntly, the iOS keyboard can be very annoying. Despite being really simple from the user’s perspective, in multiple cases the logic of the application suffers from either the lack or the misinterpretation of the system’s notifications. Below is a list of the keyboard’s notifications present in iOS:

· UIKeyboardWillShowNotification – notification sent when the keyboard is about to show.

· UIKeyboardDidShowNotification – notification sent when the keyboard has just appeared.

· UIKeyboardWillHideNotification – notification sent when the keyboard is about to hide.

· UIKeyboardDidHideNotification – notification sent when the keyboard has just been hidden.

· UIKeyboardWillChangeFrameNotification- notification sent when the kebyoard’s frame is about to change.

· UIKeyboardDidChangeFrameNotification – notification sent when the keyboard’s frame has just changed.

If we take a look at the names of keyboard’s notifications it is pretty easy to think that the typical (maybe the only correct) ‘path’ for these notifications looks like this:

In fact, these two are the most common, but when defining your application logic you can’t always expect to get all these notifications in the presented order. It is entirely normal not to get some of them in specific circumstances or to get them in a different order. Since we want our applications to provide the best user experience possible, we should know about every possible order that they may have to deal with.

UserInfo Dictionary

The UserInfo property of the NSNotification class is the only (public) way to get the keyboard frame and some specific information about the keyboard’s animation. Every notification gives the developer a snapshot of the keyboard’s present or future state and allows us to update the state of the application. These are the properties of a userInfo dictionary which are passed with every keyboard notification:

· UIKeyboardFrameBeginUserInfoKey – frame of the keyboard at the beginning of the current keyboard state change.

· UIKeyboardFrameEndUserInfoKey – frame of the keyboard at the end of the current keyboard state change.

· UIKeyboardAnimationDurationUserInfoKey – duration of the animation used to animate the change of the keyboard state.

· UIKeyboardAnimationCurveUserInfoKey – animation curve used to animate the change of the keyboard’s state.

UIKeyboardFrameBeginUserInfoKey and UIKeyboardFrameEndUserInfoKey are two most important and probably most commonly used elements of the userInfo dictionary. That being said, there is one important thing to remember. Coordinates ‘hidden’ behind these keys don’t take rotation factors applied to the window into account, so their values can seem be wrong. It is really important to remember to use convertRect:fromWindow or convertRect:fromView to make sure we work on proper keyboard coordinates.

The two following properties are most commonly used when we want to respond to a keyboard animation with our own animation. If we have the values for both the length of the animation’s duration and the curve used for the keyboard’s animation, we can use them to create our own animation, which will sync nicely with the keyboard’s own animation.

Responding to Notifications

Let’s imagine we have a view which is an UITableView object and its frame is equal to the screen bounds. In that particular case, the appearance of the keyboard will cause the bottom part of theUITableView content to be obscured by the keyboard frame. Moreover, the user won’t be able to scroll down to the bottom part of the content view which is put in table view. This is not the kind of experience we want to provide to our users.

We can handle this case in few different ways. The majority (if not all) of them require using keyboard notifications. We just listen for the appropriate notification and change some properties of our view hierarchy, so that user gets to see the entire content of the table view.

Earlier in this post, we added ourselves as the listeners for UIKeyboardWillShowNotificationusing the addObserver:selector:name:object method of the NSNotificationCenter class. Now, we can expand that code and add a method which will be called after the notification is received:

-(void)keyboardWillShow:(NSNotification *)notification {

CGRect keyboardEndFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];

UIViewAnimationCurve curve = [notification.userInfo[UIKeyboardAnimationCurveUserInfoKey] unsignedIntegerValue];

UIViewAnimationOptions options = (curve << 16) | UIViewAnimationOptionBeginFromCurrentState;

NSTimeInterval duration = [notification.userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];

CGRect frame = CGRectInset(self.tableView.frame, 0, CGRectGetHeight(keyboardEndFrame));

[UIView animateWithDuration:duration delay:0.0 options:options animations:^{

self.tableView.frame = frame;

} completion:nil];

}

This code changes the frame of the table view so that it occupies only that part of the screen which is not hidden behind the keyboard frame. Furthermore, it changes the frame using an animation that perfectly matches the keyboard animation. The animation's duration and its curve are identical to the one used to show the keyboard, so the user shouldn't even notice any changes to the table view frame. Just don't forget to return the tableView frame to its initial state after the keyboard gets hidden!

Short Summary

After reading our introduction to the notification system, you should know how to listen for or respond to keyboard notifications, you’re well-versed in the keyboard's userInfo dictionary, and spelling the names of all of the keyboard notifications is not a problem anymore.

Well, you may think that you now know everything to properly work with a keyboard. In theory that might be true, but in practice your application can sometimes exhibit some unexpected behaviors. You still don't know the order in which notifications are sent and which of them can be absent in specific circumstances. Try to think for a moment about what will happen when there’s an external keyboard connected to the iPad? Not that obvious, isn’t it?

In the following parts of this post, I’d like to explore the notifications that occur when we change the state of the keyboard, e.g. docking the keyboard, showing the keyboard when there’s an external one connected to the device, etc. Additionally, I’ll try to take a close look at the values included in theuserInfo dictionary. Finally, I’ll provide some code that will try to encapsulate some system notifications and broadcast my own. The latter notifications will have names equivalent to the system ones but will be sent in different circumstances.

Keyboard Magic

In iOS 5, Apple added a new feature to the system keyboard. Clicking and holding the keyboard button at the bottom right corner of the keyboard brings up a popup which allows you to merge/unmerge and dock/undock you keyboard. You can even move the undocked keyboard by holding and panning the abovementioned keyboard button along the screen.

Dragging keyboard triggers UIKeyboardWillChangeFrameNotification andUIKeyboardDidChangeFrameNotification notifications. First of them is send when user starts dragging and the second one after dragging is finished. Because of the fact system doesn't know what will be value of the UIKeyboardFrameEndUserInfoKey key at the beginning of the dragging, value set for this key is equal to CGRectZero in UIKeyboardWillChangeFrameNotification's dictionary. Moreover, value of the UIKeyboardFrameBeginUserInfoKey key is equal toCGRectZero in UIKeyboardDidChangeFrameNotification.

You don't get UIKeyboardWillShowNotification and UIKeyboardDidShowNotificationnotifications when a non-standard keyboard is being shown. Hiding the keyboard doesn't triggerUIKeybardWillHideNotification and UIKeyboardDidHideNotification notifications. Still, UIKeyboardWillChangeFrameNotification andUIKeyboardDidChangeFrameNotification notifications work as expected and can be used to imitate other ones (to detect when a non-standard keyboard is being shown or hidden).

How to imitate UIKeyboardWillShowNotification and UIKeyboardDidShowNotification when showing unmerged/undocked keyboard?

1. Check whether UIKeyboardDidChangeFrameNotification was not preceded byUIKeyboardWillShowNotification.

2. Check whether the rectangle from userInfo's UIKeyboardFrameEndUserInfoKey is within screen bounds.

If both of these conditions are met, the keyboard will be shown in the unmerged/undocked state. Imitating UIKeyboardWillHideNotification and UIKeyboardDidHideNotificationnotifications obviously works in almost the same way, albeit with slightly different logic. You just need to switch “within” from condition no. 2 to “not within” and you’re set. Here is the code:

- (void)keyboardWillShow:(NSNotification *)notification {

self.standardKeyboard = YES;

}

- (void)keyboardWillHide:(NSNotification *)notification {

self.standardKeyboard = YES;

}

- (void)keyboardDidHide:(NSNotification *)notification { self.standardKeyboard = NO; } - (void)keyboardDidShow:(NSNotification *)notification { self.standardKeyboard = NO; } - (void)keyboardWillChangeFrame:(NSNotification *)notification { CGRect endFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue]; UIWindow *window = [[[UIApplication sharedApplication] windows] firstObject];

endFrame = [window convertRect:endFrame fromWindow:nil];

if(CGRectContainsRect(window.frame, endFrame) && !self.standardKeyboard) {

[[NSNotificationCenter defaultCenter] postNotificationName:MCSKeyboardWillShowNotification object:nil userInfo:notification.userInfo];

} else if (!self.standardKeyboard) {

[[NSNotificationCenter defaultCenter] postNotificationName:MCSKeyboardWillHideNotification object:nil userInfo:notification.userInfo];

}

[[NSNotificationCenter defaultCenter] postNotificationName:MCSKeyboardWillChangeFrameNotification object:nil userInfo:notification.userInfo];

}

- (void)keyboardDidChangeFrame:(NSNotification *)notification {

CGRect endFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];

UIWindow *window = [[[UIApplication sharedApplication] windows] firstObject];

endFrame = [window convertRect:endFrame fromWindow:nil];

if (CGRectContainsRect(window.frame, endFrame) && !self.standardKeyboard) {

[[NSNotificationCenter defaultCenter] postNotificationName:MCSKeyboardDidShowNotification object:nil userInfo:notification.userInfo];

} else if (!self.standardKeyboard) {

[[NSNotificationCenter defaultCenter] postNotificationName:MCSKeyboardDidHideNotification object:nil userInfo:notification.userInfo];

}

[[NSNotificationCenter defaultCenter] postNotificationName:MCSKeyboardDidChangeFrameNotification object:nil userInfo:notification.userInfo];

}

Toggling Dock and Merge State

Toggling the keyboard's dock and merge states causes the notifications to be sent in slightly different order than when the keyboard’s appearing or hiding:

If we dig deeper into userInfo properties of keyboard notifications, we’ll come upon even more weirdness than we expected. When unmerging or undocking the keyboard, the value forUIKeyboardFrameEndUserInfoKey in the userInfo dictionary is different inUIKeyboardDidHideNotification than in all the other notifications. The value of this key taken from UIKeyboardDidChangeFrameNotification suggests that the keyboard will be placed either in the screen or beyond it when other notifications suggest just the opposite. Also,UIKeyboardDidChangeFrameNotification is delivered with theUIKeyboardFrameBeginUserInfoKey key of the userInfo dictionary equal to CGRectZero.

Furthermore, docking or merging results in the sending of theUIKeyboardDidChangeFrameNotification notification with the value for theUIKeyboardFrameBeginUserInfoKey key equal to CGRectZero.

Splitting/Merging When Keyboard Is Undocked

Assuming the keyboard is in an undocked state, merging and splitting the keyboard makes the notification system send notifications in the following order:

That's right - UIKeyboardDidChangeFrameNotification is sent twice although there are no differences in keyboard frames passed in the userInfo dictionary. Also, do be careful with these frames - they sometimes represent pretty useless values. UIKeyboardFrameEndUserInfoKey is equal to CGRectZero in UIKeyboardDidChangeFrameNotification andUIKeyboardFrameBeginUserInfoKey is equal to CGRectZero inUIKeyboardWillChangeFrameNotification. Why twoUIKeyboardDidChangeFrameNotification notifications? The only possible reason I found for that is captured on the screenshot underneath.

It seems that during the merging/splitting animation, there is change in the keyboard view/frame, and that’s probably the reason behind having two UIKeyboardDidChangeFrameNotificationnotifications. Just don't forget these notifications don’t always occur on a one-to-one basis!

Multiple Interface Orientations - Device Rotation

Device rotation is pretty weird when we look at it from the keyboard notification perspective. It can be really frustrating and hard to notice. Let's say your application supports multiple interface orientations and users start to rotate the device when they keyboard is displayed on the screen. What happens then? If we take a closer look at the keyboard animation which appears when we rotate the screen, we’ll quickly see that there’s nothing special to it.

But even a cursory glance at the notification logs shows us that something weird is happening. It looks like the rotation of the device makes the keyboard disappear and appear again. It’s almost imperceptible from the user’s perspective, but this notification behavior can have serious implications for the logic of the application. It looks like the easiest way to detect these notifications is to implement two templates methods of the UIViewController.

Assuming that they were implemented, this is the true order for notifications/method calls for device rotation:

1. willRotateToInterfaceOrientation:duration: - template method

2. UIKeyboardWillHideNotification

3. UIKeyboardDidHideNotification

4. UIKeyboardWillShowNotification

5. didRotateToInterfaceOrinetation:duration: - template method

6. UIKeyboardDidShowNotification

A simple flag set in willRotateToInterfaceOrientation:duration: (and unset indidRotateToInterfaceOrientation:) lets us ignore three out of the four notifications which appear during device rotation. The only one left is pretty easy to detect - if the keyboard is displayed and you get UIKeyboardDidShowNotification, don't do anything.

-(void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {

self.interfaceRotation = YES;

}

- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {

self.interfaceRotation = NO;

}

- (void)keyboardWillShow:(NSNotification *)notification {

if (self.interfaceRotation) {

return;

}

[[NSNotificationCenter defaultCenter] postNotificationName:MCKeyboardWillShowNotification object:nil userInfo:notification.userInfo];

}

- (void)keyboardDidShow:(NSNotification *)notification {

if (self.interfaceRotation) {

return;

}

[[NSNotificationCenter defaultCenter] postNotificationName:MCKeyboardDidShowNotification object:nil userInfo:notification.userInfo];

}

- (void)keyboardWillHide:(NSNotification *)notification {

if (self.interfaceRotation) {

return;

}

[[NSNotificationCenter defaultCenter] postNotificationName:MCKeyboardWillHideNotification object:nil userInfo:notification.userInfo];

}

- (void)keyboardDidHide:(NSNotification *)notification {

if (self.interfaceRotation) {

return;

}

[[NSNotificationCenter defaultCenter] postNotificationName:MCKeyboardDidHideNotification object:nil userInfo:notification.userInfo];

}

External Keyboard

Additional changes take place when we connect an external keyboard to the iPad. In this particular case, the notification behavior depends on the inputAccessoryView property of the control which was the reason for displaying the keyboard.

Let's say we have a UITextField or UITextView object and we set its inputViewAccessoryproperty. Assuming this object becomes a first responder, the view assigned to inputAccessoryView will be displayed above the keyboard on the screen. This enables programmers to provide a customized keyboard experience to the end users of the application.

If inputAccessoryView is not present or its height is equal to 0 points, no keyboard notifications are sent. My guess is that this is because in this case, no visual changes take place in application. Otherwise, all notifications behave as expected – which means they are being sent as in the majority of cases when the keyboard is displayed or hidden in a normal (not undocked or split) state.

What about the keyboard frame when inputAccessoryView is coupled with the currently displayed keyboard? Luckily for us, frames passed through keyboard notifications seem to take the displayed input view into account. That means keyboard frames passed in the objectInfo dictionary are unions of the keyboard's frame itself and the frame of the input view. Additionally, when there is an external keyboard hooked up to the device and only the accessory view is displayed, the keyboard's frame is the union of the two abovementioned frames (although the keyboard itself is not visible).

Keyboard Visibility

Due to the fact that there are so many states in which hiding or displaying the keyboard can take place, retaining a value that would inform us whether the keyboard is currently displayed on screen or not is not that obvious (and by displayed I mean visible to the user).

The easiest solution assumes the creation of a bool property which is later updated each time the system sends a UIKeyboardDidShowNotification or UIKeyboardDidHideNotificationnotification. Although really intuitive, this solution doesn't work properly when the keyboard is either undocked or unmerged.

-(void)keyboardDidShow:(NSNotification *)notification {

self.keyboardVisible = YES;

}

-(void)keyboardDidHide:(NSNotification *)notification {

self.keyboardVisible = NO;

}

A better approach to this problem is to update the bool property after we receive aUIKeyboardDidChangeFrameNotofication notification. Just removeUIKeyboardFrameEndUserInfoKey from the notification's userInfo property and check whether it is contained within screen bounds.

-(void)keyboardDidChangeFrame:(NSNotification *)notification{

CGRect endFrame = [[notification.userInfo objectForKey:UIKeyboardFrameEndUserInfoKey] CGRectValue];

UIWindow *window = [[[UIApplication sharedApplication] windows] firstObject];

endFrame = [window convertRect:endFrame fromWindow:window];

self.keyboardVisible = CGRectContainsRect(window.frame, endFrame);

}

Notice that we’re using the CGRectContainsRect function instead of CGRectIntersectsRect. This will ensure that the keyboardVisible property will be equal to YES only when the entire keyboard is visible, and by “entire keyboard” I mean keyboard + input accessory view. If you want this property to be equal to YES even when only the input accessory view is visible (when an external keyboard is connected to the device), use CGRectIntersectsRect instead.

Rultech Blog - wordpress

Rultech Blog - blogspot
Rultech Knowledge Base
Pro!deaClub Blog
Pro!deaClub - blogspot

Rultech weekly

noreply@blogger.com (Mitul Nakum) — Mon, 30 Dec 2013 07:07:00 +0000

iOS News

UIApplicationDelegate Launch Options

Is your AppDelegate.m cluttered with a lot of initialization code? There is a better way to organize all that code with launchOptions parameter. Great article from Mattt on different launchOption keys and code snippets on how to use it.

Live Editing Layout Constants

We all have spent numerous hours going back and forth arranging pixels and waiting for the app to build and look for the output on simulator. Ole has worked out a way with the help of Classy, Masonry and ClassyLiveLayout to see live edits in the simulator.

Core Bluetooth - Theoretical Overview

Great overview of Core Bluetooth APIs and best practices. iOS 7 made some great additions to the Core Bluetooth API and with iBeacon using Bluetooth LE under the hood, Apple is surely going to make more additions to it in the future versions.

Creating a Slide-out Menu with UIDynamics

UI Dynamics is the newly added library to iOS 7 that allow you to add real-world inspired interactions to your UI. Mehfuz Hossein step-by-step shows how to create a simple slide-out menu with UI Dynamics. Definitely check it out if you havent yet used UI Dynamics in your app.

Flexible and Fast Xcodebuild Formatter

Goes without saying, debugging is the most time consuming thing we do as a programmer. XCPretty library helps you format Xcode build log so you can clearly look at the error messages rather than reading between the lines.

Design

11 Steps to a Perfect Logo

Logo matters, it gives the first visual identity to your app. Its worth looking into logo creation from every perspective. Take a look at 11 of those perspectives in this great visual post.

Drag & Drop: Think Twice

Dragging things from one side of the screen to another is painful and even more so when its on a touch screen. Dave makes a good case for using touchable interface rather than drag & drop.

Business and Marketing

Switching to Freemium

Software Developer Dennis Reimann lists his reasons for switching to a freemium model for your apps. Interesting read which discusses the growing Freemium model and the App stores tendency to leave "demo" version of apps behind in search rankings.

Design Screenshots That Sell Your Apps

When words can only go so far, its up to you to screenshot the essence of your app for the respective store. Use this guide to make sure the pictures of your app are at their best.

Android News

Mirror API and GDK - Developing for Google Glass

Ever given thought to what the programming of tomorrow will look like? An Android developer walks us through a sample of what its like to develop for Google Glass.

Restricted Profile Settings

Want to allow users to limit your app access to certain profiles? Gabriele has written a great post on how to accomplish it. Netflix just started doing it, you should too!

Functional Testing For Android

If you are like me you probably hate writing tests. But its good to know your options just in case. Wiebe walks through four different functional testing frameworks in this post.

Design

Touch Gesture Icons

When words just wont do the trick you can use this collection of icons for relaying hand motions for user navigation. Fast, functional, and free.

(un)Following Guidelines

Cross-Platform development is sometimes considered the way to go but developing the app and designing it can be worlds apart. This post aims to eek developers into consideration regarding the vastly different UIs of the standard iOS and Android App.

Rultech Blog - wordpress
Rultech Blog - blogspot
Rultech Knowledge Base
Pro!deaClub Blog
Pro!deaClub - blogspot

7 Reasons Not to Update to iOS 7 so soon

noreply@blogger.com (Mitul Nakum) — Tue, 10 Sep 2013 07:00:00 +0000

The iOS 7 release date is at hand with Apple scheduled to talk iPhone 5S, iPhone 5C and iOS 7 at tomorrow’s iPhone event in Cupertino. At the event, we should hear about the iOS 7 release date and as exciting as that is, there are plenty of reasons why iPhone and iPad users might want to think about avoiding iOS 7 on its release day.

Tomorrow, Apple is set to take the stage in Cupertino to announce several new products, rumored to be the iPhone 5S and the iPhone 5C. And while much of the focus is going to be on the new iPhones, there will certainly be some talk about Apple’s new operating system, iOS 7, which is scheduled to bring a massive changes to Apple’s software for the iPhone, iPad and iPod touch.

Instead of just adding hundreds of new features like it has done in the past, iOS 7 also will be coming with a redesign for owners of Apple’s mobile products. Owners of the iPhone 5, iPhone 4S, and iPhone 4 will be seeing changes to the look of the overall user interface and the stock apps that are contained within, including the camera app and Siri.

It’s an update that is being described as the biggest change to iOS since the release of the first iPhone, a testament to just how big Apple thinks these changes are.

Soon, Apple will release iOS 7 to the public. We know that based on history which suggests that Apple will deliver an iOS 7 release date tomorrow for owners of its older devices. Rumors suggest that the iOS 7 release could come as soon as tomorrow though we expect it to be delivered sometime in between September 10th and September 20th, the latter being the rumored iPhone 5S release date.

And while there will be great excitement amongst iPhone, iPad and iPod touch owners, there are some owners that will want to hold off on downloading it on release day, either out of principal or out of necessity.

Here, we take a look at who shouldn’t install Apple’s new iOS 7 on release day.

If You’re Jailbroken

Simply put, iPhone and iPad owners who are jailbroken on iOS 6 or below, should avoid updating to iOS 7 in order to keep their device jailbroken.

While iOS 7 will be bringing some features that should be enticing to those that may have jailbroken their device on iOS 6 and below, as we’ve pointed out, there are still some reasons to remain on a jailbroken iPhone or iPad.

There is progress being made with an iOS 7 jailbreak but there is no chance that it’s going to be available on release day or any time right after it. Instead, we expect to have to wait until at least iOS 7.1 before we see an iOS 7 jailbreak roll out.

Precedent

iOS 6 saw its fair share of bugs, just like the iOS updates before it. We’ve seen issues ranging from battery life issues to Wi-Fi problems plague iOS 6 users on both the iPhone and iPad. iOS isn’t alone. Software updates from companies like Apple, Google and more typically have a bunch of bugs on board, even after extensive testing.

Expect there to be bugs in iOS 7. And expect an iOS 7.0.1 update just a few weeks later.

The iOS 7 beta period likely wiped out many of the bigger issues, but we still plan to see a collection of iOS 7 bugs and issues arise on release day. Expect battery life to be one of those issues. Last year we saw Passbook become unusable for some users right from the get-go, only to see those issues solved in the days after.

So for those that are currently experiencing a relatively bug free experience on iOS 6.1.4 or below, it might be worth holding off until iOS 7 reviews emerge in the days after its release date, or, perhaps until iOS 7.0.1 which should come a few weeks after release and be aimed at any bugs that are plaguing the initial release.

To Avoid Any Installation Issues

We often see installation issues arise on iOS release dates, either due to Apple server issues or due to other errors that pop up during the installation process. Chances are, many iPhone and iPad owners won’t encounter issues, we’ve seen Apple prepare better for iOS updates and we’ve seen errors slim down, but there is still a chance that some users will encounter problems.

We’ve seen iDevice owners run into a myriad of iOS installation issues in the past.

Those who don’t wish to deal with any of the nonsense that sometimes accompanies the installation process on release day, can simply remain patient, and wait until the issues are ironed out or solved. iOS 7 won’t be going anywhere and those who wait can install a day or two after the initial rush to grab Apple’s iOS 7 software.

If You’re Traveling

Those who are traveling may want to hold off on installing iOS 7 to their iPad or their iPhone. For one, there could be issues that affect files on board either device. This is particularly troublesome for travelers who haven’t backed up their data. If something were to go wrong, not having easy access to a personal computer could make things more difficult than they already would be as well.

Installing iOS 7 while traveling could cause headaches.

Those who are reliant on their phone or tablet when traveling should think twice about installing while on-the-go to avoid any issues that could hamper the progress of a trip.

Simply wait for the trip to be over, rely on iOS 6, and install when ready.

If You’re Unprepared

Speaking of being ready, iPhone and iPad users who aren’t prepared for the iOS 7 update should hold off on installing the software on day one. Users who won’t have time to back up their data, clean up their device, get iTunes upgraded and more, will likely want to think about holding off until all of that is done. Users who have little space on their phone might also want to think about holding off so that they have more time to determine how to best free up space for iOS 7.

If you’re not prepared for iOS 7, wait until you are to install.

Maybe more importantly, those who aren’t familiar with iOS 7 might want to hold off and read up on the big changes that will be coming with the software. For many, iOS 7 is going to be a surprise, a shock, as it is vastly different looking than iOS 6. Things will be different places, stock apps that have been the same for years will have different functionality and different looks.

The best way to acclimate to the software is by using it, but there are those that might benefit from a little extra time reading up on the update before finally taking the plunge.

If You’re Using a Work Phone

In the past, we’ve seen iOS 6 updates cause havoc for owners who are using a company iPhone. We’ve seen Exchange issues occur with iOS updates and we’ve seen folks run into battery life issues with their work phone on days when problems are unacceptable.

So, those who are using an iPhone as a work phone may want to hold off until iOS 7 bugs can be established and until a company gives the go-ahead to install the software, something that may not necessarily come on day one.

If You Have Critical Apps

Many iPhone and iPad users use applications to get them through the school day or workday. And while developers have started updating their applications for compatibility with iOS 7, there will likely be some that don’t get updates by the time iOS 7 arrives which could mean that they will not be agreeable with Apple’s new software.

Apps could be wonky after installing iOS 7.

For those are rely on apps throughout the day for work flow or something else, it’s going to be best to hold off on installing iOS 7 until an app is updated with support or if reviews indicate that the coast is clear.

Using Http Post to fill a form with HttpClient.

noreply@blogger.com (Mitul Nakum) — Thu, 17 Nov 2011 05:02:00 +0000




public StringBuilder post(String url) {
                HttpClient httpclient = new DefaultHttpClient();
                HttpPost httppost = new HttpPost(url);

                // Add your data (Var name, Var value)
                List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(3);
                httppost.getParams().setParameter(
                CoreProtocolPNames.USE_EXPECT_CONTINUE, Boolean.FALSE);
                nameValuePairs.add(new BasicNameValuePair("ageDay", "30"));
                nameValuePairs.add(new BasicNameValuePair("ageYear", "1959"));
                httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));

                // Execute HTTP Post Request
                HttpResponse response = httpclient.execute(httppost);

                // Saves response
                String line = "";
                StringBuilder result = new StringBuilder();

                BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

                while ((line = rd.readLine()) != null) {
                        result.append(line);
                }
                rd.close();

                return result;

                }

How to invert bitmap color

noreply@blogger.com (Mitul Nakum) — Thu, 17 Nov 2011 04:53:00 +0000



public static Bitmap invert(Bitmap src) {
                Bitmap output = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
                int A, R, G, B;
                int pixelColor;
                int height = src.getHeight();
                int width = src.getWidth();

            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    pixelColor = src.getPixel(x, y);
                    A = Color.alpha(pixelColor);
                    
                    R = 255 - Color.red(pixelColor);
                    G = 255 - Color.green(pixelColor);
                    B = 255 - Color.blue(pixelColor);
                    
                    output.setPixel(x, y, Color.argb(A, R, G, B));
                }
            }

            return output;
        }

Popup SMS - Android Aplication

noreply@blogger.com (Mitul Nakum) — Wed, 25 May 2011 07:23:00 +0000

Popup SMS brings you cool UI, fast and convenient SMS experience. Popup SMS provides a convenient popup dialog when a message is received that allows you to quickly read and reply or forward or call to messages. Quickly read and reply or forward or call to SMS messages from a convenient popup window. It also provides in-depth customization of message notifications including contact specific sound, vibrate and LED settings. Popup SMS is a tiny application, which is receiving SMS messages as a notification with popup. Have a useful experience with Message Popup. Similar to the SMS Popup app - but is faster, looks better, and is a pleasure to use.

Download Popup SMS form Android Market

Full feature list:
- Convenient popup window on incoming message
- Quickly reply, delete, forward, call or close the message
- Customize notifications including sound, vibrate pattern, LED color (if available).
- Also customize notifications for individual contacts
- Setup notification reminders (repeating notifications if you miss the first one)
- Optional privacy mode to hide sender name and message contents

Developed by :

- Mitul Nakum

- Sanjay Patel

- Pravin Dodia

Android 3.1 Platform : Whats new for Developers... ??

noreply@blogger.com (Mitul Nakum) — Wed, 11 May 2011 05:11:00 +0000

The Android 3.1 platform adds refinements and new capabilities that developers can build on, to create powerful and engaging application experiences on tablets and other large-screen devices.

Open Accessory API for rich interaction with peripherals

Android 3.1 introduces a new API for integrating hardware accessories with applications running on the platform. The API provides a way to interact across a wide range of peripherals, from robotics controllers to musical equipment, exercise bicycles, and more.

The API is based on a new USB (Universal Serial Bus) stack and services that are built into the platform. The platform provides services for discovering and identifying connected hardware, as well as for notifying interested applications that the hardware is available.

When a user plugs in a USB accessory, the platform receives identifying information such as product name, accessory type, manufacturer, and version. The platform sets up communication with the accessory and uses its information to notify and launch a targeted app, if one is available. Optionally, an accessory can provide a URL that lets users find and download an app that works with the accessory. These discovery features make first-time setup easier for the user and ensure that an appropriate application is available for interacting with the connected hardware.

For application developers and accessory manufacturers, accessory mode offers many new ways to engage users and build powerful interaction experiences with connected hardware.

To learn more about how to develop applications that interact with accessories, see the USB Accessory documentation.

USB host API

Android 3.1 provides built-in platform support for USB host mode and exposes an API that lets applications manage connected peripherals. On devices that support host mode, applications can use the API to identify and communicate with connected devices such as audio devices. input devices, communications devices, hubs, cameras, and more.

To learn more about how to develop applications that interact with USB devices, see the USB Host documentation.

Input from mice, joysticks, and gamepads

Android 3.1 extends the input event system to support a variety of new input sources and motion events, across all views and windows. Developers can build on these capabilities to let users interact with their applications using mice, trackballs, joysticks, gamepads, and other devices, in addition to keyboards and touchscreens.

For mouse and trackball input, the platform supports two new motion event actions: scroll (horizontal or vertical) such as from a scrollwheel; and hover, which reports the location of the mouse when no buttons are pressed. Applications can handle these events in any way needed.

For joysticks and gamepads, the platform provides a large number of motion axes that applications can use from a given input source, such as X, Y, Hat X, Hat Y, rotation, throttle, pressure, size, touch, tool, orientation, and others. Developers can also define custom axes if needed, to capture motion in additional ways. The platform provides motion events to applications as a batch, and applications can query the details of the movements included in the batch, for more efficient and precise handling of events.

Applications can query for the list of connected input devices and the motion ranges (axes) supported by each device. Applications can also handle multiple input and motion events from a single input device. For example, an application can use mouse and joystick and mouse event sources from a single input device.

Resizable Home screen widgets

Developers can now create Home screen widgets that users can resize horizontally, vertically, or both. By simply adding an attribute to the declaration of a widget, the widget becomes resizable horizontally, vertically, or both. This lets users customize the display of the widget content and display more of it on their Home screens.

MTP API for integrating with external cameras

In Android 3.1, a new MTP (Media Transfer Protocol) API lets developers write apps that interact directly with connected cameras and other PTP devices. The new API makes it easy for applications to receive notifications when devices are attached and removed, manage files and storage on those devices, and transfer files and metadata to and from them. The MTP API implements the PTP (Picture Transfer Protocol) subset of the MTP specification.

RTP API, for control over audio streaming sessions

Android 3.1 exposes an API to its built-in RTP (Real-time Transport Protocol) stack, which applications can use to directly manage on-demand or interactive data streaming. In particular, apps that provide VOIP, push-to-talk, conferencing, and audio streaming can use the API to initiate sessions and transmit or receive data streams over any available network.

Performance optimizations

Android 3.1 includes a variety of performance optimizations that help make applications faster and more responsive. Some of the optimizations include:

A new LRU cache class lets applications benefit from efficient caching. Applications can use the class to reduce the time spent computing or downloading data from the network, while maintaining a sensible memory footprint for the cached data.
The UI framework now supports partial invalidates in hardware-accelerated Views, which makes drawing operations in those Views more efficient.
A new graphics method, setHasAlpha(), allows apps to hint that a given bitmap is opaque. This provides an extra performance boost for some types of blits and is especially useful for applications that use ARGB_8888 bitmaps.

Social Texts

noreply@blogger.com (Mitul Nakum) — Wed, 20 Apr 2011 13:42:00 +0000

Publish your sms directly to Facebook wall

https://market.android.com/details?id=com.proideaclub.socialtextfress&feature=search_result

Mount NTFS partition or external drive with Read/Write permissions on MAC OS X

noreply@blogger.com (Mitul Nakum) — Fri, 18 Mar 2011 05:07:00 +0000

........ and the answer is NTFS 3G ........

NTFS-3G for Mac OS X is a software project designed to bring NTFS read/write support to Mac OS X along with additional advanced features.

It is based on NTFS-3G, the leading open source NTFS driver that is ported into numerous platforms, but also includes other software projects to build a complete toolset for managing NTFS volumes.

NTFS-3G itself is included in hundreds of Linux distributions; for example Fedora, Mandriva, openSUSE and Ubuntu use NTFS-3G as the default NTFS driver. Development has been ongoing since 2006.

Download NTFS 3G

WHAT'S NEW

Version 2010.10.2: Release notes were unavailable when this listing was updated.

REQUIREMENTS

PPC / Intel
Mac OS X 10.4 or later (the purely 64-bit kernel used by Xserves running Mac OS X 10.6 is not supported)

A freely and commercially available and supported read/write NTFS driver for Linux, FreeBSD, Mac OS X, NetBSD, Solaris, Haiku, and other operating systems. It provides safe and fast handling of the Windows XP, Windows Server 2003, Windows 2000, Windows Vista, Windows Server 2008 and Windows 7 file systems.

NTFS-3G develops, quality tests and supports a trustable, feature rich and high performance solution for hardware platforms and operating systems whose users need to reliably interoperate with NTFS.

The driver is used by millions of computers, consumer electronics devices for reliable data exchange, and referenced in more than 30 computer books. Please see our test methods and testimonials on the driver quality page at www.ntfs-3g.org.

Check if internet is available : Android

noreply@blogger.com (Mitul Nakum) — Wed, 16 Mar 2011 10:19:00 +0000

This function will return true if you can access the internet (or false if you can't). You can change the parameter being return when roaming (read the comments).

/*
* @return boolean return true if the application can access the internet
*/
private boolean haveInternet() {
NetworkInfo info = ((ConnectivityManager)getSystemService
(Context.CONNECTIVITY_SERVICE))
.getActiveNetworkInfo();
if (info == null || !info.isConnected()) {
return false;
}
if (info.isRoaming()) {
// here is the roaming option you can change it if you want to
// disable internet while roaming, just return false
return true;
}
return true;
}

In your manifest file add at least:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

What's new in iPhone OS 4 (iOS 4)

noreply@blogger.com (Mitul Nakum) — Tue, 08 Jun 2010 06:51:00 +0000

Multitasking

Applications built using iPhone SDK 4.0 or later (and running in iPhone OS 4.0 and later) are no longer terminated when the user presses the Home button; instead, they now shift to a background execution context. For many applications, this means that the application enters a suspended state of execution shortly after entering the background. Keeping the application in memory avoids the subsequent launch cycle and allows an application to simply reactivate itself, which improves the overall user experience. And suspending the application improves overall system performance by minimizing power usage and giving more execution time to the foreground application.

Although most applications are suspended shortly after moving to the background, applications that need to continue working in the background may do so using one of the following techniques:

An application can request a finite amount of time to complete some important task.
An application can declare itself as supporting specific services that require regular background execution time.
An application can use local notifications to generate user alerts at designated times, whether or not the application is running.

Regardless of whether your application is suspended or continues running in the background, supporting multitasking does require some additional work on your part. Background applications can still be terminated under certain conditions (such as during low-memory conditions), and so applications must be ready to exit at any time. This means that many of the tasks you used to perform at quit time must now be performed when your application moves to the background. This requires implementing some new methods in your application delegate to respond to application state transitions.

Integration Technologies

The following sections describe the technologies you can use to enhance your application’s user experience.

Local Notifications

Local notifications complement the existing push notifications by giving applications an avenue for generating the notifications locally instead of relying on an external server. Background applications can use local notifications as a way to get a user’s attention when important events happen. For example, a navigation application running in the background can use local notifications to alert the user when it is time to make a turn. Applications can also schedule the delivery of local notifications for a future date and time and have those notifications delivered even if the application is not running.

The advantage of local notifications is that they are independent of your application. Once a notification is scheduled, the system manages the delivery of it. Your application does not even have to be running when the notification is delivered.

Event Kit

The Event Kit framework (EventKit.framework) provides an interface for accessing calendar events on a user’s device. You can use this framework to get existing events and add new events to the user’s calendar. Calendar events can include alarms that you can configure with rules for when they should be delivered. In addition to using Event Kit for creating new events, you can use the view controllers of the Event Kit UI framework (EventKitUI.framework) to present standard system interfaces for viewing and editing events.

Core Motion

The Core Motion framework (CoreMotion.framework) provides a single set of interfaces for accessing all motion-based data available on a device. The framework supports accessing both raw and processed accelerometer data using a new set of block-based interfaces. For devices with a built-in gyroscope, you can retrieve the raw gyro data as well as processed data reflecting the attitude and rotation rates of the device. You can use both the accelerometer and gyro-based data for games or other applications that use motion as input or as a way to enhance the overall user experience.

Data Protection

Applications that work with sensitive user data can now take advantage of the built-in encryption available on some devices to protect that data. When your application designates a particular file as protected, the system stores that file on-disk in an encrypted format. While the device is locked, the contents of the file are inaccessible to both your application and to any potential intruders. However, when the device is unlocked by the user, a decryption key is created to allow your application to access the file.

Implementing data protection requires you to be considerate in how you create and manage the data you want to protect. Applications must themselves be designed to secure the data at creation time and to be prepared for changes in access to that data when the user locks and unlocks the device.

Core Telephony

The Core Telephony framework (CoreTelephony.framework) provides interfaces for interacting with phone-based information on devices that have a cellular radio. Applications can use this framework to get information about a user’s cellular service provider. Applications interested in cellular call events can also be notified when those events occur.

iAd

You can use iAd (iAd.framework) to deliver banner-based advertisements from your application. Advertisements are incorporated into standard views that you integrate into your user interface and present when you want. The views themselves work with Apple’s ad service to automatically handle all the work associated with loading and presenting the ad content and responding to taps in those ads.

Graphics and Multimedia

High-Resolution Screen Support

For the most part, applications running on devices with high-resolution screens should work with little or no modifications. The coordinate values you specify during drawing or when manipulating views are all mapped to a logical coordinate system, which is decoupled from the underlying screen resolution. Any content you draw is automatically scaled as needed to support high-resolution screens. For vector-based drawing code, the system frameworks automatically use any extra pixels to improve the crispness of your content. And if you use images in your application, UIKit provides support for loading high-resolution variants of your existing images automatically.

Quick Look Framework

The Quick Look framework (QuickLook.framework) provides a direct interface for previewing the contents of files your application does not support directly. This framework is intended primarily for applications that download files from the network or that otherwise work with files from unknown sources. After obtaining the file, you use the view controller provided by this framework to display the contents of that file directly in your user interface.

AV Foundation

The AV Foundation framework (AVFoundation.framework) is for applications that need to go beyond the music and movie playback features found in the Media Player framework. Originally introduced in iPhone OS 3.0, this framework has been expanded in iPhone OS 4.0 to include significant new capabilities, substantially broadening its usage beyond basic audio playback and recording capabilities. Specifically, this framework now includes support for the following features:

Media asset management
Media editing
Movie capture
Movie playback
Track management
Metadata management for media items
Stereophonic panning
Precise synchronization between sounds
An Objective-C interface for determining details about sound files, such as the data format, sample rate, and number of channels

The AV Foundation framework is a single source for recording and playing back audio and video in iPhone OS. This framework also provides much more sophisticated support for handling and managing media items.

Assets Library

The Assets Library framework (AssetsLibrary.framework) provides a query-based interface for retrieving a user’s photos and videos. Using this framework, you can access the same assets that are nominally managed by the Photos application, including items in the user’s saved photos album and any photos and videos that were imported onto the device. You can also save new photos and videos back to the user’s saved photos album.

Image I/O

The Image I/O framework (ImageIO.framework) provides interfaces for importing and exporting image data and image metadata. This framework is built on top of the Core Graphics data types and functions and supports all of the standard image types available in iPhone OS.

Core Media

The Core Media framework (CoreMedia.framework) provides the low-level media types used by AV Foundation. Most applications should never need to use this framework, but it is provided for those few developers who need more precise control over the creation and presentation of audio and video content.

Core Video

The Core Video framework (CoreVideo.framework) provides buffer and buffer pool support for Core Media. Most applications should never need to use this framework directly.

Core Services

Block Objects

Block objects are a C-level language construct that you can incorporate into your C, C++, and Objective-C code. A block object is a mechanism for creating an ad hoc function body, something which in other languages is sometimes called a closure or lambda. You use block objects in places where you need to create a reusable segment of code but where creating a function or method might be too heavyweight or inflexible.

In iPhone OS, blocks are commonly used in the following scenarios:

As a replacement for delegates and delegate methods
As a replacement for callback functions
To implement completion handlers for one-time operations
To facilitate performing a task on all the items in a collection
Together with dispatch queues, to perform asynchronous tasks

Grand Central Dispatch

Grand Central Dispatch (GCD) is a BSD-level technology that you use to manage the execution of tasks in your application. GCD combines an asynchronous programming model with a highly optimized core to provide a convenient (and more efficient) alternative to threading. GCD also provides convenient alternatives for many types of low-level tasks, such as reading and writing file descriptors, implementing timers, monitoring signals and process events, and more.

Accelerate Framework

The Accelerate framework (Accelerate.framework) contains interfaces for performing math, big-number, and DSP calculations, among others. The advantage of using this framework over writing your own versions of these libraries is that it is optimized for the different hardware configurations present in iPhone OS–based devices. Therefore, you can write your code once and be assured that it runs efficiently on all devices.

Framework Enhancements

UIKit Framework Enhancements

The UIKit framework includes the following enhancements:

The UIApplication class and UIApplicationDelegate protocol include new methods for scheduling local notifications and for supporting multitasking.
Drawing to a graphics context in UIKit is now thread-safe. Specifically:
- The routines used to access and manipulate the graphics context can now correctly handle contexts residing on different threads.
- String and image drawing is now thread-safe.
- Using color and font objects in multiple threads is now safe to do.
The UIImagePickerController class includes methods for programmatically starting and stopping video capture. It also includes options for selecting which camera you want to use on a device and for enabling a built-in flash.
The UILocalNotification class supports the configuration of local notifications; see “Local Notifications.”
The UIView class includes new block-based methods for implementing animations.
The UIWindow class has a new rootViewController property that you can use to change the contents of the window.
Media applications can now receive events related to the controls on an attached set of headphones. You can use these events to control the playback of media-related items.
Several new accessibility interfaces help you make some UI elements more accessible and allow you to customize your application experience specifically for VoiceOver users:
- The UIAccessibilityAction protocol makes it easy for VoiceOver users to adjust the value of UI elements, such as pickers and sliders.
- UIPickerViewAccessibilityDelegate protocol enables access to the individual components of a picker.
- UIAccessibilityFocus protocol allows you to find out when VoiceOver is focused on an element, so you can help users avoid making unnecessary taps.
- The UIAccessibilityTraitStartsMediaSession trait allows you to prevent VoiceOver from speaking during a media session that should not be interrupted.
- New interfaces in UIAccessibility protocol allow you to specify the language in which labels and hints are spoken, and provide announcements that describe events that don't update application UI in way that would be perceptible to VoiceOver users.
The UINib class provides a way to instantiate multiple sets of objects efficiently from the same nib file.

Foundation Framework Enhancements

The Foundation framework includes the following enhancements:

Most delegate methods are now declared in formal protocols instead of as categories on NSObject.
Block-based variants are now available for many types of operations.
There is new support for creating and formatting date information in NSDate and NSDateFormatter.
The NSDateComponents class added support for specifying time zone and quarter information.
There is support for regular-expression matching using the NSRegularExpression, NSDataDetector, and NSTextCheckingResult classes.
The NSBlockOperation class allows you to add blocks to operation queues.
You can use the NSFileManager class to mark files as protected; see “Data Protection.”
The NSFileWrapper class allows you to work with package-based document types.
The NSOrthography class describes the linguistic content of a piece of text.
The NSCache class provides support for storing and managing temporary data.
The URL-related classes have been updated so that you can now pipeline URL requests and set request priorities.

OpenGL ES Enhancements

The OpenGL ES framework includes the following enhancements:

The APPLE_framebuffer_multisample extension enables full-scene anti-aliasing.
The EXT_framebuffer_discard extension can be used to improve the performance of applications that use depth buffers or multisample framebuffers.
The APPLE_texture_max_level and EXT_shader_texture_lod extensions provide more control over texture sampling.
The OES_vertex_array_object (http://www.khronos.org/registry/gles/extensions/OES/OES_vertex_array_object.txt) API allows caching of vertex array state, to decrease driver overhead.
The OES_depth_texture extension enables rendering real-time shadows using shadow maps.
The OES_texture_float (http://www.khronos.org/registry/gles/extensions/OES/OES_texture_float.txt) and OES_texture_half_float (http://www.khronos.org/registry/gles/extensions/OES/OES_texture_float.txt) extensions adds texture formats with floating point components to enable High Dynamic Range rendering.
The APPLE_rgb_422 (http://www.opengl.org/registry/specs/APPLE/rgb_422.txt) extension enables texturing from some common video formats.
Performance of texture creation and modification has been significantly improved.
Driver performance has been generally improved.

Game Kit Enhancements

The Game Kit framework includes a beta implementation of a centralized service called Game Center. This service provides game developers with a standard way to implement the following features:

Aliases allow users to create their own online persona. Users log in to Game Center and interact with other players anonymously through their alias. Players can set status messages as well as mark specific people as their friends.
Leader boards allow your application to post scores to Game Center and retrieve them later.
Matchmaking allows players to connect with other players with Game Center accounts.

Important: GameCenter is available to developers only in iPhoneOS 4.0. It is introduced as a developer-only feature so that you can provide feedback as you implement and test Game Center features in your applications. However, Game Center is not a user feature in iPhone OS 4.0 and you should not deploy applications that use it to the App Store.

Core Location Enhancements

The Core Location framework now supports the following features:

A location monitoring service that tracks significant changes using only cellular information. This solution offers a lower-power alternative for determining the user’s location.
The ability to define arbitrary regions and detect boundary crossings into or out of those regions. This feature can be used for proximity detection regardless of whether the application is running.

Map Kit Enhancements

The Map Kit framework includes the following enhancements:

Support for draggable map annotations
Support for map overlays

Draggable map annotations make it much easier to reposition those annotations after they have been added to a map. The Map Kit framework handles most of the touch events associated with initiating, tracking, and ending a drag operation. However, the annotation view must work in conjunction with the map view delegate to ensure that dragging of the annotation view is supported.

Map overlays provide a way to create more complex types of annotations. Instead of being pinned to a single point, an overlay can represent a path or shape that spans a wider region. You can use overlays to layer information such as bus routes, election maps, park boundaries, and weather maps on top of the map.

Message UI Enhancements

The Message UI framework includes a new MFMessageComposeViewController class for composing SMS messages. This class manages a standard system interface for composing and sending SMS messages. In contrast with sending SMS messages using a specially formatted URL, this class allows you to create and send the message entirely from within your application.

Core Graphics Enhancements

The Core Graphics framework includes the following enhancements:

The ability to embed metadata into PDF files using the CGPDFContextAddDocumentMetadata function
Support for creating color spaces using an ICC profile
Graphics context support for font smoothing and fine-grained pixel manipulation

ICU Enhancements

The International Components for Unicode (ICU) libraries were updated to version 4.4. ICU is an open-source project for Unicode support and software internationalization. The installed version of ICU includes only a subset of the header files that are part of the broader ICU library. Specifically, iPhone OS includes only the headers used to support regular expressions.

Inherited Improvements

Although iPhone OS 3.2 does not run on iPhone and iPod touch devices, many of the features introduced in that version of the operating system are also supported in iPhone OS 4.0. Specifically, iPhone OS 4.0 supports:

Custom input views
Connecting external displays
File-sharing support
Gesture recognizers
Core Text for text layout and rendering
Text input through integration with the keyboard
Custom fonts
ICU Regular Expressions
Document types
PDF generation
Xcode Tools changes
UIKit framework changes
Media Player framework changes
Core Animation changes
Foundation framework changes

Android 2.2 Platform Highlights

noreply@blogger.com (Mitul Nakum) — Fri, 21 May 2010 06:16:00 +0000

The Android 2.2 platform introduces many new and exciting features for users and developers. This document provides a glimpse at some of the new user features and technologies in Android 2.2. For more information about the new developer APIs, see the Android 2.2 version notes.

New User Features

Home

New Home screen tips widget assists new users on how to configure the home

screen with shortcuts and widgets and how to make use of multiple home screens.

The Phone, applications Launcher, and Browser now have dedicated shortcuts on

the Home screen, making it easy to access them from any of the 5 home screen panels.

Exchange support

Improved security with the addition of numeric pin or alpha-numeric password

options to unlock device. Exchange administrators can enforce password policy

across devices.

Remote wipe: Exchange administrators can remotely reset the device to

factory defaults to secure data in case device is lost or stolen.

Exchange Calendars are now supported in the Calendar application.

Auto-discovery: you just need to know your user-name and password to easily

set up and sync an Exchange account (available for Exchange 2007 and higher).

Global Address Lists look-up is now available in the Email application, enabling

users to auto-complete recipient names from the directory.

Camera and Gallery

Gallery allows you to peek into picture stacks using a zoom gesture.

Camera onscreen buttons provide easy access to a new UI for controlling zoom,

flash, white balance, geo-tagging, focus and exposure. Camcorder also provides

an easy way to set video size/quality for MMS and YouTube.

With the LED flash now enabled for the Camcorder, videos can be shot at night

or in low light settings.

Portable hotspot

Certain devices like the Nexus One can be turned into a portable Wi-Fi hotspot
that can be shared with up to 8 devices.

You can use your Android-powered phone as a 3G connection for a Windows or

Linux laptop by connecting their phone to the computer with a USB cable. The connection is then shared between the two devices.

Multiple keyboard languages

Multi-lingual users can add multiple languages to the keyboard and switch

between multiple Latin-based input languages by swiping across the space

bar. This changes the keys as well as the auto-suggest dictionary.

Improved performance

Performance of the browser has been enhanced using the V8 engine, which
enables faster loading of JavaScript-heavy pages.

Dalvik Performance Boost: 2x-5x performance speedup for CPU-heavy code

over Android 2.1 with Dalvik JIT.

The graph to the right shows the performance speedup from Android 2.1 to

Android 2.2 using various benchmark tests. For example, LinPack is now more

than 5 times faster.

Kernel Memory Management Boost: Improved memory reclaim by up to 20x,

which results in faster app switching and smoother performance on memory-

constrained devices.

New Platform Technologies

Media framework

New media framework (Stagefright) that supports local file playback and HTTP progressive streaming

Continued support for OpenCore in Android 2.2

Bluetooth

Voice dialing over Bluetooth
Ability to share contacts with other phones
Support for Bluetooth enabled car and desk docks
Improved compatibility matrix with car kits and headsets

2.6.32 kernel upgrade

HIGHMEM support for RAM >256MB
SDIO scheduling and BT improvements

New Developer Services

Android Cloud to Device Messaging

Apps can utilize Android Cloud to Device Messaging to enable mobile alert, send to phone, and two-way push sync functionality.

Android Application Error Reports

New bug reporting feature for Android Market apps enables developers to receive crash and freeze reports from their users. The reports will be available when they log into their publisher account.

New Developer APIs

Apps on external storage

Applications can now request installation on the shared external storage (such as an SD card).

Media framework

Provides new APIs for audio focus, routing audio to SCO, and auto-scan of files to media database. Also provides APIs to let applications detect completion of sound loading and auto-pause and auto-resume audio playback.

Camera and Camcorder

New preview API doubles the frame rate from ~10FPS to ~20FPS. Camera now supports portrait orientation, zoom controls, access to exposure data, and a thumbnail utility. A new camcorder profile enables apps to determine device hardware capabilities.

Graphics

New APIs for OpenGL ES 2.0, working with YUV image format, and ETC1 for texture compression.

Data backup

Apps can participate in data backup and restore, to ensure that users maintain their data after performing a factory reset or when switching devices.

Device policy manager

New device policy management APIs allow developers to write "device administrator" applications that can control security features on the device, such as the minimum password strength, data wipe, and so on. Users can select the administrators that are enabled on their devices.

UI framework

New "car mode" and "night mode" controls and configurations allow applications to adjust their UI for these situations. A scale gesture detector API provides improved definition of multi-touch events. Applications can now customize the bottom strip of a TabWidget.

For more information about the new developer APIs, see the Android 2.2 version notes and the API Differences Report.

How to play video and audio on Android

noreply@blogger.com (Mitul Nakum) — Wed, 12 May 2010 13:30:00 +0000

There is more than one way, to play media files on an Android phone, let me show you two of them.

Audio:
MediaPlayer is the easier way, if you just want to play an audio file in the background, somewhere in an appliaction. There are no ui controls here, but of course you can use MediaPlayer.stop(), play(), seekTo() ,etc. Just bind the needed functions to a button, gesture, or event. As you can see, it also throws a lot of exceptions, which you need to catch.

public void audioPlayer(String path, String fileName){
    //set up MediaPlayer    
    MediaPlayer mp = new MediaPlayer();
 
    try {
        mp.setDataSource(path+"/"+fileName);
    } catch (IllegalArgumentException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IllegalStateException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    try {
        mp.prepare();
    } catch (IllegalStateException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    mp.start();
}

Video:
In this example, I open a video file, and decide if I want it to autoplay after it is loaded.
You propably want to store your video files, on the sd card. You can get the path to the sd card via: Environment.getExternalStorageDirectory().

public void videoPlayer(String path, String fileName, boolean autoplay){
    //get current window information, and set format, set it up differently, if you need some special effects
    getWindow().setFormat(PixelFormat.TRANSLUCENT);
    //the VideoView will hold the video
    VideoView videoHolder = new VideoView(this);
    //MediaController is the ui control howering above the video (just like in the default youtube player).
    videoHolder.setMediaController(new MediaController(this));
    //assing a video file to the video holder
    videoHolder.setVideoURI(Uri.parse(path+"/"+fileName));
    //get focus, before playing the video.
    videoHolder.requestFocus();
    if(autoplay){
        videoHolder.start();
    }
 
 }