Android Content Provider/SQLite Methods

There are a number of key methods for accessing data via an Android Content Provider or directly on the underlying SQLite database.  The table below summarizes the method parameters and return values. The graphic is from the video training course Learning Android App Programming.

B-tree and Binary Search Tree Data Structures

B-tree and Binary Search Tree data structures are similar but different ways to store data. The advantage of using search trees is that the test for membership can be performed efficiently provided that the tree is reasonably balanced, that is, the leaves of the tree are at comparable depths.

B-tree Implementations

B-tree implementations are normally commercial. Languages don't typically provide direct B-tree support. To find B-tree implementations, search Google for B-tree software.

Binary Search Tree Implementations

Some languages do provide support for Binary Search Trees. In Java, see the TreeMap class, which implements a variant of the Binary Search Tree, the Red-Black Tree.

Binary Tree Data Structure Comparison

Both structures operate in the average in O(log n) time. Note that in the worst case, B-tree, at O(log n), is faster than Binary Search Tree at O(n).

P Versus NP Complexity Theory

The P Versus NP issue deals with whether every problem whose solution can be quickly verified by a computer can also be quickly solved by a computer. This is a major unsolved problem in computer science.

In common, practical terms, it deals with how to identify problems that are either extremely difficult or impossible to solve.  In order of difficulty from easy to hard, problems are classified as P, NP, NP-Complete and NP-Hard.

So why do we care? When approaching complex problems, it's useful to have at least some idea of whether the problem is precisely solvable, or if an approximation is the best that can be accomplished. 

Big O Notation

Big O notation is a way to characterize the time or resources needed to solve a computing problem.  It's particularly useful in comparing various computing algorithms under consideration. Below is a table summarizing Big O functions. The four most commonly referenced and important to remember are:

  • O(1)              Constant access time such as the use of a hash table.
  • O(log n)        Logarithmic access time such as a binary search of a sorted table.
  • O(n)              Linear access time such as the search of an unsorted list.
  • O(n log(n))   Multiple of log(n) access time such as using Quicksort or Mergesort.

Sorting Algorithms

Before delving into the large variety of sorting algorithms, it's important to understand that there are simple ways to perform sorts in most programming languages. For example, in Java, the Collections class contains a sort method that can be implemented as simply as:

Collections.sort(list);

where list is an object such as an ArrayList. Some aspects of the Java sort() method to note are:

  • You can also use the Java Comparator class methods to implement your own list item comparison functions for specialized sorting order needs.
  • The Java Collections class (plural) is different than the Collection class (singular).
  • Which sorting algorithm (see below) is used in the Collections.sort() implementation depends on the implementation approach chosen by the Java language developers. You can find implementation notes for Java Collections.sort() here. It currently uses a modified merge sort that performs in the range of Big O O(n log(n)).

If you don't want to use a built-in sort function and you're going to implement your own sort function, there's a large list of sorting algorithms to choose from.  Factors to consider in choosing a sort algorithm include:

  • Speed of the algorithm for the best, average and worst sort times. Most algorithms have sort times characterized by Big O functions of O(n), O(n log(n)) or O(n^2).
  • The relative importance of the best, average and worst sort times for the sort application.
  • Memory required to perform the sort.
  • Type of data to be sorted (e.g., numbers, strings, documents).
  • The size of the data set to be sorted.
  • The need for sort stability (preserving the original order of duplicate items).
  • Distribution and uniformity of values to be sorted.
  • Complexity of the sort algorithm.

For a comparison of sorting algorithms based on these and other values see: https://en.wikipedia.org/wiki/Sorting_algorithm#Comparison_of_algorithms.

Here's a quick reference for the major algorithms:

  • Exchange Sorts: based on swapping items
    • Bubble sort: for each pair of indices, swap the items if out of order, loop for items and list.
    • Cocktail sort: variation of bubble sort, passes alternately from top to bottom and bottom to top.
    • Comb sort: variation of bubble sort, selective swap of values
    • Gnome sort: also called the stupd sort, moves values back to just above a value less than it
    • Odd-even sort: developed originally for use with parallel processors, examines odd-even pairs and orders them, alternates pairs until list is ordered
    • Quicksort: divide list into two, with all items on the first list coming before all items on the second list.; then sort the two lists. Repeat. Often the method of choice. One of the fastest sort algorithms
  • Hybrid Sorts: mixture of sort techniques
    • Flashsort: Used on data sets with a known distribution, estimates used for where an element should be placed
    • Introsort: begin with quicksort and switch to heapsort when the recursion depth exceeds a certain level
    • Timsort: adaptative algorithm derived from merge sort and insertion sort. 
  • Insertion sorts: builds the final sorted array one item at a time
    • Insertion sort: determine where the current item belongs in the list of sorted ones, and insert it there
    • Library sort: like library shelves, space is created for new entries within groups such as first letters, space is removed at end of sort
    • Patience sorting: based on the solitaire card game, uses piles of "cards"
    • Shell sort: an attempt to improve insertion sort
    • Tree sort (binary tree sort): build binary tree, then traverse it to create sorted list
    • Cycle sort: in-place with theoretically optimal number of writes
  • Merge sortstakes advantage of the ease of merging already sorted lists into a new sorted list
    • Merge sort: sort the first and second half of the list separately, then merge the sorted lists
    • Strand sort: repeatedly pulls sorted sublists out of the list to be sorted and merges them with the result array
  • Non-comparison sorts
    • Bead sort: can only be used on positive integers, performed using mechanics like beads on an abacus
    • Bucket sort: works by partitioning an array into a number of buckets, each bucket is then sorted individually using the best technique, the buckets are then merged
    • Burstsort: used for sorting strings, employs growable arrays
    • Counting sort: sorts a collection of objects according to keys that are small integers
    • Pigeonhole sort: suitable for sorting lists of elements where the number of elements and number of possible key values are approximately the same, uses auxiliary arrays for grouping values
    • Postman sort: variant of Bucket sort which takes advantage of hierarchical structure
    • Radix sort: sorts strings letter by letter
  • Selection sorts: in place comparison sorts
    • Heapsort: convert the list into a heap, keep removing the largest element from the heap and adding it to the end of the list
    • Selection sort: pick the smallest of the remaining elements, add it to the end of the sorted list
    • Smoothsort
  • Other
  • Unknown class

 

Android Release and Device Support Summary

Below is a summary of Android releases and device support.  It shows that by using the  Android Support Libraries you can code your apps to run on a large percentage of Android devices.

For more information on the compatibility Support Libraries see: http://developer.android.com/tools/extras/support-library.html 

For more information on Device Support see: http://developer.android.com/about/dashboards/index.html

Android WebView Combines Native and HTML5 Code

A battle is raging over whether native mobile code apps, such as those for Android and iOS, are a better approach than using HTML5.  Each has its advantages.

There is, though, a way to blend the two in order to take advantages of the benefits each has to offer.  The graphic below shows the anatomy of an app that displays an HTML5 Canvas on an Android screen display.

This app is from the Learning Android App Programming video training course.

The HTML5 Canvas animation displayed is from HTML5 Canvas for Dummies.

You can see the HTML5 Canvas animation by clicking here. To see the JavaScript code that generates the animation, right click on the display page and select View Source Code.

Android Bound Services Using Inter Process Communications

Android Service components can be implemented using a number of mechanisms.  If you want your Service to be able to communicate with other applications running in separate processes, using Inter Process Communications (IPC) is one approach.

The diagram below shows the major classes and methods needed in the binding activity and bound service.  The details of this implementation can be found on the Android Developers Web site here on the Bound Services page

In summary, the major classes involved are:

  • Service - Application component for longer-running operations that do not interface directly with the user.
  • ServiceConnection - Interface for monitoring a service.
  • Messenger - Creates a Messenger pointing to a Handler in one process, and handing that Messenger to another process.
  • Message - Description and arbitrary data object that can be sent to a Handler.
  • IBinder - Interface for a remotable object.
  • Handler - allows you to send and process Message and Runnable objects associated with a thread's MessageQueue.

Android/PHP/JQuery RESTful JSON MySQL Client-Server Overview

The title of this blog entry is quite a mouthful.  The purpose is to give a broad overview of the moving parts necessary to implement an application with client mobile and desktop devices that interact with a server database to alter and retrieve data.

I won't define all the classes, methods and acronyms on the graphic as they're easy to look up using an Internet search.  There are other choices that can be made for the details of the implementation, but this should provide a starting point for thinking through the necessary elements.

The communication vehicle for client-server interaction is typically the Internet Protocol Suite.

 

Android Broadcast Receivers

Broadcast Receivers are one of the four basic Android components, along with Activities, Services and Content Providers.  Broadcast Receivers respond to Intents issued by the Android system or Android apps.  It's one way to respond to "things happening" on the user device.

The video below from the training course Learning Android App Programming explains the basics of Broadcast Receivers.

SQL Database Join Operations

It can be challenging to remember the details of all the SQL Join operations.  A convenient way to do this is to use Venn diagrams shown below. For examples of SQL Joins, go here

Commonly used SQL Join operations are:

  • inner join: requires each record in the two joined tables to have matching records.
  • outer join: does not require each record in the two joined tables to have a matching record.

Android Button Listener Code Dissected

Android listeners are the mechanism used to respond to user interaction with a display screen.  Setting up a listener is a very common Android coding task.  Although it can be done with just a few lines of code, it involves a number of elements that must be configured to interact correctly.

The diagram below from the video training course Learning Android App Programming dissects the code to establish a listener for a screen button.

Android Service Methods

Android Services can be configured to run in the same thread as the interface activity or a separate background thread.  The diagram below from the video training course Learning Android App Programming details the methods used to start, stop and send messages to a service.

Android Cursor Interface

An Android Cursor provides read-write access to a data set from an SQL Database.  The Android Cursor interface is a bit of a naming paradigm misdirection.  We normally think of a cursor as an indicator on our computer screen as to where we can type.  And we usually think of the cursor as primarily moving horizontally. he Android Cursor is more complex than this and its cursor movement is primarily vertical, indicating rows in a matrix.  You can think of a Cursor as providing access to an array of data.

The chart below from the video training course Learning Android App Programming provides some convenient visual cues to help understand and remember Android Cursor functionality.

Android User Interaction Through Listeners and Toasts

Every Android App interacts with its users.  There are lot's of ways to implement this interaction, but two basic capabilities are listeners and toasts.

Click here to see a video from Learning Android App Programming demonstrating a Listener and Toast to give you a basic understanding of these important and useful techniques.

Android Development Using API Demos

Google provides API Demos apps for various releases of the Android system.  These apps contain hundreds of demos of Android capabilities.  They demonstrate the use of tens of thousands of lines of code and can be a big help to developers as they create their own apps.

However, the API Demos apps are not well documented and it can be difficult to find the code within them for a given function.  In authoring a recently released video tutorial course for Android Developers, I addressed this issue by creating an Excel worksheet that gives developers a tool to better understand the structure of the API Demos and to search the demos based on keywords to find the code they need.

A video explaining the use of API Demos is below...

Describes how to use Android API Demos. From the course Learning Android App Programming published by InfiniteSkills. More information is available at http://donkcowan.com/android-development-course/

Creating a 3D Effect in 2D HTML5 Canvas Games

HTML5 Canvas doesn’t include a built-in 3D context. Without using an add-on product such as WebGL (www.khronos.org/webgl), 3D has to be simulated using the 2D context.

Some games require the sophistication of a true 3D engine like WebGL. However, many games built using the Canvas 2D context can be significantly enhanced by simulating aspects of 3D motion.

In the Ballpark sample game from HTML5 Canvas for Dummies, the thrown baseball is simulated moving away from the ball thrower toward the ball player along a simulated z axis third dimension. The z axis 3D effect is accomplished by decreasing the size of the baseball in proportion to it's movement upward along the 2D y axis.

You can play the game yourself by clicking here.  To see the full code, right click on the game web page and select View Page Source.

To simulate 3D movement using this technique, the following steps were used:

1.    Assign a z axis variable to each new object.

Along with the xPos and yPos variables, assign a zPos variable as in code section S2 assignments for baseballs:

     ball[b].zPos = zStart;

2.    As the object moves, update the z position.

In the sample game, in code section R8, the z position is calculated based  on the y axis position (yPos) and a z sizing factor (zSizeFact):

     var newZPos  = (ball[b].yPos/canvasBL.height) * zSizeFact;

     ball[b].zPos = newZPos;  

3.    Fix the z position under specified conditions.

In the sample game, the baseball is simulated to move along the z axis only away from the ball thrower. Also, to simplify the simulation, only movement up the y axis is used to increase z axis movement. So, when the ball starts to move down on the y axis, the z position is fixed. This code is in sections R9-R12:

     // FIX Z position of zFix is greater than zero.      

     if(ball[b].zFix > 0)  {ball[b].zPos = ball[b].zFix};

     // Z FIX check for not already set.

     if(ball[b].zFix == 0)

     {   // Z FIX conditions check. 

        var newYPos  = ball[b].yPos;

        if(((newYPos > curYPos) || (ball[b].bounce)) && (curYPos < zFixMaxY))

        {  // FIX Z POSITION at current level and no smaller than minSize.

           ball[b].zFix = Math.max((curYPos/canvasBL.height)*zSizeFact, minSize);   }   }