To get into the right mood, a few of the follow-up questions from a few chapters in “The Heart of Yoga”, by T.K.V. Desikachar, 1995 (published by Inner Traditions International, Rochester VT)

Biography of Sri. T. Krishnamacharya:

The father of T.K.V. Desikachar, Krishnamacharya was from a family of advisors. Like his ancestors he gave advice to leaders, and was sought out for his wisdom. Learned Sanskrit, and studied the texts of the great masters of the north (of India), as well as Tamil masters from the south. Combined in a unique practical way.

As a healer he was always concerned for the sick, even while a student. Krishnamacharya met Krishna Kumar and helped promote Aryuveda learning how to heal with yoga, and ayurveda – learned to take pulses of his advisees.

His yoga was unique because of how he took an individualistic approach for each student. Always focused on the student. Desikachar felt it was important to fit the lesson to the student’s situation.

Vinyasa krama

– from Desikachar’s description it’s important to practice intelligently, thinking it through, and understanding the implications of what yoga you want to do.

A few important yoga texts, for reference:

• Yoga Sutra (Patanjali)
• Yoga Rahasya (Nathamuni)
• Bhagavad Gita
• Predipika (basis of Hatha yoga)

Sannyasin

A dedicated life, committed to the eight limbs of yoga, and giving up “family life”. It means giving yourself to a higher power; and in an identifiable way it means wandering about, and begging for food. The followers of sannyasin are identifed by the orange rodes which they wear.

“Advanita Vedanta”

Yoga is the step toward advaita. Advaita vendanta is the recognition of the duality which exists to drive the need to pursuit unity. Without the duality there’s be no pursuit. Those who pursue such a unity are known as Advaita Vendantists.

In Desikachar’s writing the different styles of yoga is an obvious result of the number of people who learn yoga. Yoga is not fixed, but rather yoga is a creation. The way you teach is different; even within the Mandiram institute (Desikachar’s school) the teachers vary – there should always be instruction to where the student is “at”. It should provide many styles.

Definition of Yoga

• To unite
• To tie together the strands of the mind, applied both to physical, and the mental or intention
• To obtain what was previously unobtainable. Acting in a way which focussed our intention on the task at hand.
• To be one, with the divine

Avidya

False perception.
Or, that which interferes with our having a correct understanding (or vidya), the accumulated result of our many unconscious actions

There are four branches of avidya:

• Ego – asmita: thought such as “I have to be better than others”
• Want – raga: making demands (evn if you don’t need)
• Rejecting – dvesa: avoiding the ungamiliar or difficult experiences
• Fear – adbinivesa: feeling uncertain, doubts about our position in life

Perusa  (and how it is different from avidya):

That which is true, deep within us. As the true and very real (not subject to change) and which sees correctly. Avidya is the clouding of that true/correct view with misunderstanding or a lack of clarity.

We achieve higher levels of consciousness, or “go up the ladder” by three things (according to the yoga sutras:

tapas

practice of asanas, and pranayama in the exercises, get rid of blocks and impurities in our systems

svadhyaya

self-study, investigation (getting to know ourselves)

isvarapranidhana

– “love of god”, and a certain quality of action; sincerity and intention.

Asanasa

The concept of asanas includes “shira and sukha”, meaning both steadiness, and alertness (shira) and also the ability to remain comfortable in a pose (sukha). In Paranjali’s yoga sutra he stressed that we need both in our postures (asanas).

The first step in yoga practice is consciously linking our breath and our body; which is to say our breath and our movement.

When you exhale, contract the body – conversely, when you inhale expand.  And, be sure the breathing initiates the movement.

The movement of the diagrragm during the breath, is key:

• diaphragm moves downward on inhale
• the lungs fill, and then move back to rest
• on inhale expands rib cage (making ribs raise, moves diaphragm down)
• on exhale the opposite happens contraction of the chest, diaphragm comes back up

counter poses exist for all postures

Every posture has positive/negative effects, and counter pose can off-set the negative effects of a pose.

Dynamic and Static Anasana

The dynamic practice repeats into a pose and out again in rhythm to the breath. Where-as the static asanas will hold a pose for multiple breaths, directing our attention to our breath. It’s ALWAYS BETTER to practice the dynmaic asana before holding it.

Principals, from Desikachar’s constructing a practice

• begin where you are
• warm up and loosen the whole body at the start
• before you perform an asana, make sure you know and can perform an appropriate counter pose
• practice an asana dynamically before holding it.
• practice the counter pose immediately following the asana
• make sure the counter pose is simpler than the main asana

Ways to use the breath to change or intensify the yoga practice:

HOLDING can intensify the effects of the asana in the abdominal area. On inhale, holding uour breath is intense in the chest.

REST between asanas. Rest give a change to feel the effects of the posture.

What are the ways we vary an asana?

• very the form
• vary the breath
• vary the rhythm
• vary the preparation (the pose which leads to this asana)
• vary the sphere of attention (which part of the body we focus on)

Or, my blog entries regarding the free tools for doing an Android based Java development.

<various topics>of Jim’s Blog entries (all sorts of miscellaneous topics)
Jim Donovan lives in the Boston suburbs, and makes blog entries on technical topics in software development tools, software quality, initiatives in green energy and conservation as well as yoga, meditation, as well as chronicles of his family history. Profile LINKto his “Microsoft LIVE”, Facebook, or Linked-In profile

A few of the first words, quick summary for reference.

• abhinivesa – source of fear, attachment to life, one of the klesas
• abhyasa – practice
• adho mukha svanasana – downward facing dog
• advaita – non dualism
• ahamkara – sense of “I”
• ahimsa – non injuring
• ananda – state of bliss
• ananta – without end
• antaraya – obstacle to a clear and stable mind
• aparigraha – to recieve the exact right amount you need
• ardha utkatasana – half squat pose
• asana – posture / pose, literally “seat”
• asmita – sense of ego
• astanga – eight limbs
• asteya – not coveting
• avidya – incorrect knowledge, most important of the klesas
• bandha – to bind or lock
• Bhagavad Gita – the epic where Krsna teaches yoga to Arjuna
• bhakti – devotion
• bhakti yoga – a yoga practice recognizable for chanting (Krishna Das)
• bhujangasana – corpse pose 
• cakras – energy centers along the spinal column
• cakravakasana – cat pose
• darsana – one of six classical point of view in Indian thought
• dhanurasana – bow pose
• dharana – a specific point
• dharma duty – ethical value
• dhyana – meditation
• dvesa – dislike/hatred; one of the klesas
• eka pada uttanasana – standing pose, with torso bends forward and one lef lifted behind
• halasana – plow pose
• Hatha Yoga Pradipika – classical text on Hatha yoga
• kaivalya – ultimate state of yoga, freedom
• karma yoga – action is done as duty with no concern for success or failure
• klesa – affliction
• kriya – action
• kundalini – obstacle in spine center prevents movement of prana into susumna
• mahamudra – classic sitting pose
• mantra – sacred sound
• matsyendrasana – a half spinal twist
• prana vayu – one of the five main life energies
• pranayama – regulated breathing techniques
• pratikriyasana – counter pose
• pratyahara – withdrawal of the senses
• raga – attachment or desire, one of the klesas
• sadhana – practice
• sakti – power
• samadhi – enlightenment
• samtosa – contentment, one of the niyamas
• sannyasin – one who’s given up everything but God
• sarvangasana – shoulder stand
• satya – truthfulness, one of the yamas
• sirsasana – head stand
• sthira – steadiness alertness
• sukha – lightness and comfort happiness
• sukhasana – simple crossed-leg pose seated
• surya namaskar – sun salutation
• susumna – of spine from base to top of head
•  

Or, my blog entries regarding the free tools for doing an Android based Java development.

<various topics>of Jim’s Blog entries (all sorts of miscellaneous topics)
Jim Donovan lives in the Boston suburbs, and makes blog entries on technical topics in software development tools, software quality, initiatives in green energy and conservation as well as yoga, meditation, as well as chronicles of his family history. Profile LINKto his “Microsoft LIVE”, Facebook, or Linked-In profile

Whether applied to a yoga posture, or to your general disposition on life; it’s good advice.

The hard part sometimes is to focus on a small change, without disturbing all the things which are already right. Sometimes, you try to fix one small thing, and throw off everything else.

So, one of the most memorable “adjustments” in a yoga class happened when an instructor guided my arms into a better alignment, but started with the above phrase – and, it stuck with me. I often would start correcting my posture even before the instructor said anything, and it can make you lose your overall good posture for the sake of trying to extend into something you’re not ready to do. So, the advice: “keep everything else the same” allows you to stay focused on the parts of a pose which are working. Remember, to remember, what’s RIGHT in your pose.

And, what’s right in life – sometimes, you want to start a new endeavor, like yoga for example… and, everything else in your busy schedule gets thrown off.  Try to keep your life on an even keel, while adding something good; but, don’t go overboard and make other things get out of alignment.

<summary> of Jim’s blog entries on yoga topics.
<other topics>of Jim’s blog entries (a variety of miscellaneous topics)
Jim Donovan lives in the Boston suburbs, and makes blog entries on technical topics in software development tools, software quality, initiatives in green energy and conservation as well as yoga, meditation, and sometimes chronicles of his family history. Profile LINK to his “Microsoft LIVE”, Facebook, or Linked-In profile.

Sounds like a dread disease: “Persistent Data”, like you were in paralysis or had psoriasis – but, it just means “using a database” for your handheld App.

Instead of reading a file, or just keeping a bunch of variables in memory – we choose to leverage the thousands of years of development experience into our own app with a database. The books on these subjects discuss how “SQLite” is likely the most deployed data repository in the world (consider the hundreds of millions of phones deployed, and how prolific smart phones are becoming – eh, maybe it’s true!).

As advocated in earlier Blog entries – Get a good book on this subject, my suggestion: Ed Burnette’s “Hello Android”, $32.95 or from his web site: Pragmatic Bookshelf. ($28 for a paper printed version of the 3rd Edition – official release, expected in July 2010)

When you read his book…  you will also find the forums/discussions very helpful.  Check out:  http://forums.pragprog.com/forums/152 

Web resources, to help in figuring these DB aspects of your App out:

Dev-X Overview           http://www.devx.com/wireless/Article/40842/1954 

“Future Yard” Blog, with code samples      http://futureyard.blogspot.com/2009/05/genericdao-for-android-sqlite.html

Needing a few tables, both to drive the data we preserve over time and also the convenience of user interface means finding a convenient and practical storage mechansim.

We also want to model the data relationships.

The site, to get started, is at: http://argouml.tigris.org

Another, is from Visual Paradigm.      Seemingly arbitrary decisions, based in part on the “open source” versions being available.

             http://www.visual-paradigm.com/download/vpuml.jsp?edition=ce 

To retreat, or not to retreat!?!! …is there a question?

When we first considered attending a weekend yoga retreat we had only been doing yoga for a few months and it seemed like a silly idea. But, a few instructors we knew have organized the weekend – it sounded interesting, a bit excessive; maybe. And, mostly we remember thinking: “how could anyone do that much yoga?” – it would have to be like an endurance challenge and rather an overdose (and, maybe very strenuous or outright exhausting!).

It was none of that.  We did decide to go, and we enjoyed the whole weekend. We found some new friends that we both keep in touch with, and look forward to going back to the same spot years later. Our first impression of getting away for a yoga weekend, was a very positive experience.

So, there you have our bias – so, you will have to take the following with that same predisposition toward having a good time, at a get-a-way which both relaxes us, and heightens our appreciation for your yoga practice.  With the right leadership, a retreat can be an excellent experience. The concern about “doing too much” yoga all at once, can simply be alleviated by assuring you that skipping any number of the actual yoga practices can guarantee that you can’t overdue how much yoga is a good yoga. And, even if you skip a majority of the yoga session, you’ll still benefit from the get-away-from-things to experience some breathing and stretching and just relishing the company of new found friends and probably some good food (maybe even GOOD FOR YOU food).

But let me clarify – there are retreats, and there are retreats. Consider, the “yoga conference” of a nationally marketed and advertised retreat with a bunch of world class yoga “names” who all lead hundreds of students in large resorts or major hotel chain where someone you might recognize from a DVD video, or maybe a TV show or movie can make you feel like you are the only one in the room, with their mere presence. They are world famous, for a reason – they’re awesome. But, it’s not to be confused with the local yoga studio that you get to know and love the personal attention you benefit from one-on-one friendly and attention.

A hotel conference center is a weird place to do yoga. Walking around a convention hall in bare feet is strange, even if everyone else is doing it too. When a conference is so large that they use masking tape to assure that the 100 mats will all fit within the allotted space – that’s weird too. But, even considering the contradiction of “successful yoga celebrity” it’s valuable time to experience the world of western yoga popular sharing of yoga experience. There’s something to be said about a hundred people all chanting a mantra. Maybe it’s not your cup of tea – but, there’s something to be said.

It may be expensive. And, you may just never get comfortable with the juxtaposition of a big conference and yoga, and maybe that’s just something you don’t need to explore to know for yourself.  That dove-tails into the basic built-in contradiction of a “big” yoga conference…  seems to me that yoga is meant to be experienced at a personal level – and, something about celebrity and crowds seems impersonal.   On the other hand, there is no denying that Sean Korn, or Rodney Yee, and the other recognizable names are popular because they are amazing practitioners of some great yoga practices, philosophies, and message.  The couple of times I tried a “Yoga Journal” conference – I was pretty impressed, and learned a bunch of things from their teachers.

The very best retreats I’ve participated in, were organized by a small resort in NH: Purity Spring, and also one in Vermont which was organized by the Karme Choling meditation center.  Check their web sites for more details.  With a group of people who you get to know in a very personal way – it’s likely to be one of your “top ten” most memorable experiences and will give you something you can carry with you for years to come.

When you “sign up” for some retreat you do want to be sure what you are getting into – it could be a Caribbean paradise with an awesome instructor; but you may also stumble into a straw hut with a guide who’s never taught a few classes …how do you know??!? Talk to other people at your favorite studio – or just make sure you go with an instructor you already trust. You may be surprised that a popular way to get away is with a studio that retreats together.

<summary> of Jim’s blog entries on yoga topics.
<other topics>of Jim’s blog entries (a variety of miscellaneous topics)
Jim Donovan lives in the Boston suburbs, and makes blog entries on technical topics in software development tools, software quality, initiatives in green energy and conservation as well as yoga, meditation, as well as chronicles of his family history. Profile LINK to his “Microsoft LIVE”, Facebook, or Linked-In profile.

An easy means of navigation within an application’s screens, or to access additional features and settings without losing of focus from the main screen of an application is by using menus.

To look closer, it’s the [MENU] button of the smart phone case (not just part of a touch screen); it provides consistent means of accessing options, settings, and common properties of many of the Smartphone apps. Usually, it’s just one or two rows; and no more than three items per row.

Here, the system menu is shown, which allows adding shortcuts or applications on the main Android screen. At the system menu we also can modify the wallpaper on the main screen, or to go into the settings, notifications, and/or for a quick access to searching both on your handheld or on the web. The Clock shown in this screen capture was added to the main Android screen by using this menu, and then “Add” to find “Widgets” from which “Analog Clock” was selected.

Adding a menu feature into our own application requires a combination of Java code changes, XML settings, and modifications to the Android Manifest file to apply to the screens of an Application.

Clicking on one of the menu options starts a new activity and brings up a new screen. In this tutorial, we will add a menu to an existing application (activity). That menu will have a single option — to display an "about" screen. We will start at the end (the display) and work toward the beginning (the menu click) so references are defined when we need them.

An outline of the steps we will take:

1. Create the XML for the "about" screen with text that talks "about" application.

2. Create a new activity class in java code which will display the "about" screen.

3. Add this new activity to the manifest.

4. Define the menu in XML, identifying the option(s) to be available.

5. Modify the existing activity to include code to reference the menu and direct the

actions which occur when a menu option is selected.

THE “ABOUT” ACTIVITY

A new XML file is created in the res/layout directory to describe the ABOUT screen . In our case, this is a very simple screen. It has one TextView that contains all the text that we want to display. We have placed this TextView with a ScrollView so that the text will scroll if it exceeds the space available on the screen. Note that line breaks included in the text will appear on the screen; without line breaks the text will wrap.

res/layout/about.xml

<?xml version="1.0" encoding="utf-8"?>
<ScrollView
xmlns:android=http://schemas.android.com/apk/res/android
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:padding="10dip">

<TextView
android:id="@+id/about_content"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="19sp" android:textColor="#ffffff"
android:text="FuelTrak is an application for tracking the MPG of your vehicle by calculating the gallons purchased and the number of miles driven. Multiple vehicles are supported. The inputs are maintained as a log to record the efficiency over time indicating things like servicing indicators and overall gasoline consumption and driving records for the months and years you drive your car." />
</ScrollView>

A new java file is created in the src directory to show the ABOUT screen. Again, this is very simple. The class ABOUT is defined as an extension of the ACTIVITY class, and upon creation the activity will set the context view to the about screen we defined above.

src/project/about.java

package com.donovanden.refuel;
import android.app.Activity;
import android.os.Bundle;

public class About extends Activity {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.about);
    }
}

This new activity must be included in the Manifest, so it is known to the project.

Android/Manifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=http://schemas.android.com/apk/res/android
package="com.donovanden.refuel"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon"
android:label="@string/app_name">
<activity android:name=".Combined"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".About"
android:label="About"
android:theme="@android:style/Theme.Dialog">
</activity>
</application>
<uses-sdk android:minSdkVersion="7" />
</manifest>

ADDING THE MENU

Now we are ready to define the menu itself. This is done with a new XML file in the res/menu directory. This is not a regular layout file, but an XML file which has one ITEM for each option on the menu. We only define one which will display the title "About" and is referenced by R.id.about_menuitem.

res/menu/menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/about_menuitem" android:title="About"></item>
</menu>

Finally, we add code to the activity which supports the menu. First we add code which creates the menu and "inflates" the display at the bottom of the screen to show the menu options. To use this code, you will need to import three classes.

src/project/main.java

import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;

public boolean onCreateOptionsMenu(Menu menu) {
    super.onCreateOptionsMenu(menu);
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.menu, menu);
    return true;
}

The resources in the R. reference above are key – specified in the hierarchy which Eclipse is managing for us – the orange “.menu” references a folder we are keeping menu specifications in, and the purple “.menu” is for the file named “menu.xml”. From the Android library, the inflate function needs these xml definitions, and expects a “menu” parameter which is the location of the structures we used for the menu definition. The second parameter to the inflate function specifies where that memory is located.

It remains a mystery to us the purpose of the incoming parameter named "menu" in this method. It appears to be something internal. When the menu is called (created) by pressing the MENU key, the inflater builds the menu screen based on our items specified in R.menu.menu (res/menu/menu.xml).

Then we add code to link a click on the menu option to our desired action — the display of the about screen (by starting the About activity).

src/project/main.java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.about_menuitem:
        startActivity(new Intent(this, About.class));
    }
    return true;
}

This method detects clicks on the menu items. We determine which item was selected by comparing the MenuItem (passed as a parameter to the method) to the item id’s that we established in res/menu/menu/xml. Of course, in the present case there is only one item, but this "switch" code allows for easy upgrade for additional items. When the user clicks on the ABOUT button, the About activity (as defined in the manifest) is initiated.

ADDING SETTINGS

Now let’s expand our menu to include another item – we will allow the user to adjust "settings" for the application. Android has a special class to handle these settings called PreferenceActivity — and each setting is called a "preference"..

Again we start by building the screen which is used to set the preferences. Instead of building a screen layout, this involves an xml file this lists each preference and is stored in res/xml directory

res/xml/settings.xml

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android">
<CheckBoxPreference
android:key="fulltank"
android:title="fulltank title"
android:summary="fulltank summary"
android:defaultValue="true" />
<CheckBoxPreference
android:key="units"
android:defaultValue="true"
android:summary="use Gallons and Miles"
android:title="Imperial units"/>
<CheckBoxPreference
android:key="other"
android:title="other title"
android:summary="other summary"
android:defaultValue="false" />
</PreferenceScreen>

Now create the java file for the class activity which displays these settings. Note that this activity does not use setContextView, but addPreferencesFromResource (a built in part of PreferenceActivity that does a lot of the work for us).

src/project/Preferences.java

package com.donovanden.project;
import android.os.Bundle;
import android.preference.PreferenceActivity;
public class Preferences extends PreferenceActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        addPreferencesFromResource(R.xml.settings);
    }
}

This new activity must be included in the Manifest.

Android/Manifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=http://schemas.android.com/apk/res/android
package="com.donovanden.refuel"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon"
android:label="@string/app_name">
<activity android:name=".Combined"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".About"
android:label="About"
android:theme="@android:style/Theme.Dialog">
</activity>
<activity android:name=".Preferences"
android:label="Settings ">
</activity>
</application>
<uses-sdk android:minSdkVersion="7" />

Add an new item to the menu for navigation to the new settings screen

res/menu/menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/about_menuitem" android:title="About" />
<item android:id="@+id/settings_menuitem" android:title="Settings" />
</menu>

The menu code has already been added to our base activity; we only need to update the coded action on the click (when users selects a menu option).

src/project/main.java

public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.about_menuitem:
        startActivity(new Intent(this, About.class));
        case R.id.settings_menuitem:
        startActivity(new Intent(this, Preferences.class));
    }
    return true;
}

Adding the class definition for the references in is easiest in a separate .java file.

For example, the line of Java code:

startActivity(new Intent(this, Preferences.class));

has the reference to an instance of the Preferences.class, which is shown here:

/***
*   My preferences:
*   March 18, 2010
***/
package com.example.FuelTracker;

import android.os.Bundle;
import android.preference.PreferenceActivity;

public class Preferences extends PreferenceActivity {
   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      addPreferencesFromResource(R.xml.settings);
   }
}

NOTE:  It’s NOT important that Preferences is called Preferences, but it is inheriting PreferenceActivity (that name, IS IMPORTANT).

We are creating a new activity – this has an associated Linux process behind the scenes, but what is important is that when it’s started, the menu inherits the appearance (usually) and the behaviours of a menu (from it’s parent class: PreferenceActivity). This includes the popping to the front at the bottom of the Android platform’s screen, and allowing the user to select one of these defined items from the menu.xml declaration. When selected, the activity executes – and, then terminates. (NEED TO CHECK, does it terminate, does it?).

The key statement here, as a function which calls “addPreferencesFromResource” and pass it the XML definitions in “settings”.

Refer to the res\xml\settings.xml file:

<PreferenceScreen
   xmlns:android="http://schemas.android.com/apk/res/android">
   <CheckBoxPreference
      android:key="fulltank"
      android:title="fulltank title"
      android:summary="fulltank summary"
      android:defaultValue="true" />
   <CheckBoxPreference
      android:key="units"
      android:title="Imperial units title"
      android:summary="Imperial system, meaning Gallons and Miles"
      android:defaultValue="true" />
   <CheckBoxPreference
      android:key="other"
      android:title="other title"
      android:summary="other summary"
      android:defaultValue="false" />
</PreferenceScreen>

Notice in the above XML code, we’ve listed some of the extra directives; for example: “defaultValue” is either set to “true” or “false” to predetermine the setting the first time that the preference screen appears.  What may not be aparrent is that the title or summary values may be a string reference to an associated XML file.  But, for this first example it seems easier to just enter the text definitions directly.  If you use the Eclipse plug-in, these string value references to the strings.xml file in the values folder of the project are the way it’s usually defined.

The graphic version of these entries can also be used (screen shot, from V3.5 Eclipse, with Android Plug-in)

When (I’d say “if”, except that it’s a pretty much CERTAINTY that you’ll see this occur) you get an error, which results in an unexpected termination of the program… there is NOT a lot of hints provided to describe the problem.  It may be that you are starting an activity which doesn’t have a class associated with it; or your code to create that class doesn’t exist, or has errors in the logic.   But, backing up to the working version (comment out the lines which start the activity) may be helpful.

To address this, the likely oversight in adding menu code into your applications is resolved when you update the Manifest.

To look more closely at the lines in the manifest which are important for the menu:

For each added activity, a name is specified (and, inferred, there’s a source file and class defined for it).

<activity android:name=".Preferences"
      android:label="Settings inManifest">
</activity>

This establishes the association of the “.Preferences” class, with this activity which was called above from the main “OnCreateMenu” function.

Revisiting:

In the XML file for the menu, when we specify a string value for the title it looked like:

<item android:id="@+id/settings"
    . . .
    android:title="Settings"
    .

We notice the more official approach is to use a reference to the strings file.

<item android:id="@+id/settings"
    .
    android:title="@string/settings_label"

These indirect references to the string’s value is supported by the Eclipse v3.5 IDE when you have the Android plug-in.  The “keyboard shortcut” and other definitions should similarly be replaced with the strings;  we will presume that it’s better especially for internationalization, and likely other facilities within the Android SDK and the IDE to be using a centralized location for all these values.   For now, the direct text entry seems easier to a first time experience. The same case would be made for the “settings.xml” file.

In the project’s hierarchy, there’s a “res” resource folder which contains layout information, string values, menus, and even XML definition.

In the same directory, a collection of drawable resources are typically maintained for different target systems at various resolutions. The normal, is “mdpi” but there’s compatibility with “hdpi” and “ldpi” as well as just the original “drawable” directory.

In the “drawable” folder, a good place to keep the “icon.png” file, which probably already was defined to have a 48×48 pixel (with 24bit color depth) image (of the android robot (the little green guy).

NOTE:  This Blog entry is a DRAFT, it is NOT complete (as of March 8rd, 2010) so…   take the following with a grain of salt, so to speak, until this disclaimer line has been removed.

If you haven’t already edited that image – adapt your own idea of an appropriate icon for your application.

For use of other images you want to place into your canvas areas – put the image into these same folder series.   And then reference them in the Java code you write, such as:

    Resources res = this.getResources();
    Bitmap mBitmap = BitmapFactory.decodeResource(res, R.drawable.gaspump);
    canvas.drawBitmap(mBitmap , 0, 10, imgPaint);

There may be a “thread” of execution, thru which you need to access the resources which your IDE is maintaining as collections of datastructures.  In my case, the “getResource” call will provide the handle to the Eclipse managed Resources, specifically — "res\drawable”.   With the library called BitmapFactory we can decode the .PNG formatted graphics – to create a type “Bitmap” object.

From here – the function drawBitmap() is used to render that image on my canvas.  

[ MORE ]

A good instructor will lead a yoga class where the poses transition smoothly; and guide students thru a sequence of poses which keep the students interested, and challenged, without being overwhelmed or bored. It’s almost magical when everyone in a class feels that the practice was exactly what they needed – like it was matched to their individual level for everyone at the same time.

A great instructor – takes that another level further, to help improve the posture of students in the class, while exploring new poses, and

Being confident in a yoga practice builds slowly over time, and when you find a healthy balance between enjoyment and relaxation which comes from a comfortable practice, and the challenge and learning which comes from exploring new poses and gaining more insight into your world and your place in it – you know you are getting the benefits which can come from a regular and growing practice.

With a session in March 2010 to learn about adjustments, and aligning which was lead by YogaThree, I was inspired by learning about how the most popular asanas are often done by students, and how subtle changes in the poses can be improved – and, how specifically to adjust people who are learning yoga be become even better. The workshop was for instructors; but, also for those who are serious about yoga and want to better understand their own practice, to improve! I learned quite a bit about my own practice …and, actually, could imagine myself as leading a practice to share my enthusiasm for yoga. It was enlightening.

This was the first time that I’d understood that a lot of the regular poses have specific “right ways” to do them – and, even within various philosophies of a practice there are many good ways to encourage those who are learning!

With the session at the Yoga Loft (Jen Ryan’s studio, in Wilmington MA) I have looked more closely at the instructor training series for the fall – and, look forward to taking the practice to a new level to learn how to lead yoga practice to share the benefits of yoga with others.

Or, my blog entries regarding the free tools for doing an Android based Java development.

<various topics>of Jim’s Blog entries (all sorts of miscellaneous topics)
Jim Donovan lives in the Boston suburbs, and makes blog entries on technical topics in software development tools, software quality, initiatives in green energy and conservation as well as yoga, meditation, as well as chronicles of his family history. Profile LINKto his “Microsoft LIVE”, Facebook, or Linked-In profile
]]> http://jmdonovan.wordpress.com/2010/03/06/yoga-%e2%80%93-adjustments-alignment-and-the-subtle-differences-of-a-pose/feed/ 0 jmdonovan Jim2004_05b http://jmdonovan.wordpress.com/2010/03/03/android-%e2%80%93-using-eclipse-3-5-ide-with-java-android-dsk-plug-in-changing-a-domain-name-in-the-project/ http://jmdonovan.wordpress.com/2010/03/03/android-%e2%80%93-using-eclipse-3-5-ide-with-java-android-dsk-plug-in-changing-a-domain-name-in-the-project/#comments Wed, 03 Mar 2010 14:40:44 +0000 jmdonovan http://jmdonovan.wordpress.com/2010/03/03/android-%e2%80%93-using-eclipse-3-5-ide-with-java-android-dsk-plug-in-changing-a-domain-name-in-the-project ]]>

It seems like it should be an easy task, to modify the source code hierarchy and reflect a new domain name into the source “.java” files.

BUT, there’s a lot of behind the scenes parsing taking place – so, be wary… and don’t undertake this effort until you’ve reserved time to recover from the variety of changes you need to make; and it goes without saying that you should make a backup of your source code before you get started. Well, there… I said it… so it didn’t got without saying.

NOTE:  This Blog entry is a DRAFT, it is NOT complete (as of March 3rd, 2010) so…   take the following with a grain of salt, so to speak, until this disclaimer line has been removed.

When you create a package, it has a built in name (or, you GAVE it a name) implying the domain name, for example “org.example” is used a lot.
SOURCE FILES, are placed in the reverse hierarchy implied with that name. If it was “org.example” then the files for the project are placed in:

          ..\src\org\example\ProjectName

And, inside each Java source file, there’s package specifiers, such as:

package org.example.ProjectName;

This means the Eclipse preprocessors will look for declarations which fit into the specified scope.

If you change the domain name, then the source file directories are out of sync. And, visa-versa, if you modified the source file first then the folder hierarchy would be out of sync. You need to open each source file, and modify the package declaration as well.

It would be nice if it ended there – but, you’ll find other source file references to the “org.example” string, so change those as well.

One example, as a likely candidate, is the TAG variable which can be used for tracing features built into the IDE for purposes of tracking execution thru the application; this is handy, and should also be kept in sync with the package’s declaration.

Of course, it is helpful to start using the right references within the code as early as is practical in your projects such that the changes are simpler to make.  Don’t just rely on the examples and code from a book to define the source code hierarchy – adapt them to your own domain name. Do it early!

Now, when you have changed the source files, and source folder hierarchy, you also need to reflect this into your AndroidManifest.XML file.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="org.example.ProjectName"

Note: when you modify that manifest file, the Eclipse IDE will prompt you to ask if it should update the “Run Configurations”, which is a convenience – so, SURE let it do that for you!

A bit further down in the Manifest description of your package, is a description of the “application” including activity name, the icon location, etc – this too, is an important part of changing the project.  You often change the main directory, the main file, and the application’s name – these must be consistent!

<application android:icon="@drawable/icon" android:label="@string/app_name">
    <activity android:name=".ProjectName"
              android:label="@string/app_name">

AND, also look in the “strings.xml” file for the string which defines “app_name” (this is used as the value which appears under your application’s icon in the Android desktop; so, it’s important to use the right value for that string, as well!

Finally, don’t be shy about expunging the “gen” folder, and the “bin” folders – it’s easiest, and most thorough to just ruthlessly delete the top level folders (that is “org” in our example here where “org.example” was the old domain name which is being replaced with a companyname.com as the new name).  You will notice these folders get quickly replaced with the new replacement names. It is just as easy to delete the folder from the top level when you want to truly clear out all intermediate data. The entire folder structure is replaced, immediately after the delete operation is complete (so, don’t think that your delete didn’t work – it did! And, was immediately re-created – so, DO THIS DELETE as the LAST STEP when you have renamed everything!

Having done all this – you may still find that you need to “close” the project.  And, maybe even shutdown the Eclipse environment – and, even still, may find that the build process is aborted, and the only error message in the Console window indicates that an instance of the old domain name still exists.

I still can’t find it, on one of my projects – even though I have repeated this process of conversion a number of times successfully on other projects.
[ THIS IS WHY my disclaimer ABOVE still indicates this BLOG is a “draft” ]

Additional commentary:

Source code should follow the open source project “Code Style Guide”, it’s here:

http://source.android.com/submit-patches/code-style-guide

 

What’s not described above, is WHY, and there are probably better explanations… but the key is that creating a new package needs to be universally unique – meaning across every existing instance of an Android based portable computing device.

http://developer.android.com/resources/tutorials/hello-world.html

Doug Adams was a big ahead of his time. But, not multiple centuries, as th readers of the Hitchhiker’s Guide might have presumed — it’s already coming true, today!

Consider the computers most of us use daily; and the access we usually have access to at our fingertips. I got a netbook for Christmas – it’s nice.  You know… it’s like a laptop, but smaller; well, but it has a 10.3” screen so it is an ideal size.  The keyboard isn’t tiny like a cell phone – you can really type on it. The guts of the computer have an actual hard disk (I don’t know how they make a disk so small – but they do), and it is running a version of Microsoft Windows.   That too, is amazing. On an older computer at home which has only one gigabyte of memory the Microsoft Windows software runs really slowly – but, on this Netbook it seems pretty nice.

Without getting into gory details, the netbook had 1GB of memory which was pretty usable; we upgraded it to 2GB and it’s even better. I don’t suggest you try to use Outlook and PowerPoint and Word all at the same time – but, maybe think of it as being able to run one program very well, or multiple programs appreciably slower.

So, having now used it for a month or so I am happily surprised that I like it so much.  I’d like to relate how much of Douglas Adams science fiction writing of ~20 years ago has come true. It’s like being able to carry around my hitch-hiker’s guide to the [local] galaxy – but, it’s a very real accessory for a traveler in today’s world of technology.

Having it for reading my email is to be expected. It’s just a basic expected feature of any internet capable device. The instant access to maps at my finger tips is ho-hum. We expect to be able to look-up movie listings at our favorite theaters. These are all features that you’d presume just because a portable device with WiFi can access the internet. Indeed, no surprise.

Seriously enough you really do start to use a Netbook anywhere, and everywhere, because you can. The information available is something we come to expect; and often demand.  Being able to get access to the internet when we check into a hotel, or even stop by at a coffee shop has become casual and routine.  So, the netbook is an excellent means of providing access, and making it conveniently portable for light and easy handy option.

What I have been finding new and exciting is how prolific the free and easy media outlets are – most recently with free books, and movies which I can enjoy even when my internet tether is disconnected.  Watching a movie which was downloaded, and reading one of the many books in my library – it’s remarkable.

Even reading a classic – by downloading the Amazon Kindle for PC, and grabbing a few books.   It was a matter of minutes to get started.

It’s good idea to start with a few “free” books, to be sure you like the electronic version of reading! It is a different experience than reading a book published with paper – but, there are plusses and minuses.  The big plus, is that you can carry a bunch of them around, simultaneously; and you can book mark to quickly come back to the same spot …for quick references. The minus, of course, is that you have to turn it on. In fact, there are a number of subtle side effects of that single disadvantage – on an airplane, I like to read a paperback book because they can’t make you turn it off during take-off and landings. Turning it on, means that your time of reading the screen is in competition with all the other things you do on your computer, like reading e-mail, or writing, or ~work~ …so, suddenly, the time to escape in a great novel is now competing for time on the computer along with all the other work related and personal time you spend on-line and plugged in.

In short – the netbook is a great alternative to spending a bunch of money on a laptop. It’s fair to mention that if you want to do multiple things at the same time, maybe a real laptop is required. And, if you are accustomed to having a desktop computer, then the Netbook may not satisfy your need for a full-size computer with portability.  If you already have a laptop, and only use a few things – you may find that the netbook is sufficient for many of those things.

The gravitational shift of the laptop being a center of my computer universe has now been replaced with the internet representing the center of an internet enabled world. My “data” no longer needs to be duplicated here, locally.  I am getting used to this idea. Now, I can trust Google, and Microsoft (and, a few other

Google is a major participant in the “free storage” and “free applications” for networked access. Being able to keep your documents on-line, and access your calendar on-line, and your e-mail on-line… it’s all good stuff. Now, with being able to download software tools, and office automation tools, and personal productivity tools.  It is all good stuff.  And, the world is at your finger tips.  And, it’s pretty in-expensive.

ALSO READ:   Free, free, free

Or, my blog entries regarding the free tools for doing an Android based Java development.

<summary> of Jim’s various technical subjects, and
<other topics>of Jim’s Blog entries (all sorts of miscellaneous topics)
Jim Donovan lives in the Boston suburbs, and makes blog entries on technical topics in software development tools, software quality, initiatives in green energy and conservation as well as yoga, meditation, as well as chronicles of his family history. Profile LINK to his “Microsoft LIVE”, Facebook, or Linked-In profile.