Possible Solution: Wipe emulator with the following command

emulator -wipe-data -avd TheNameOfYourAVD

Probable Cause: Expired Debug certificate

#!/bin/bash
if[ $# -eq 1 ]
echo You've entered one argument: $1
else
echo Please enter one argument
fi

This week, I have “formally” started writing my thesis. I’m trying to emphasize the “formally” here since I’ve been trying to start it like… I don’t know… n-weeks ago(?)… writing bits and pieces of junk that I don’t know if it will even be part of the final paper later on, or will just be thrown out and rewritten entirely in the end.

I just discussed and “finalized” my outline last week with my adviser, that is why this week, I have tried to focus on trying to reorganize it and put it all together again. So far, I spent this week just trying to organize stuff that I have written/gathered before (old publications, notes, etc.), and trying to battle with latex to come up with a nice formatting for my thesis. If you’re not familiar with latex, it’s sort of a scripting language that you use to format your documents… you know, simple formatting that will take a second if you use NORMAL word processors, will take a hell-lot of time just to accomplish in latex. I think half of the time I’ve spent this week on my \emph{thesis writing} was just trying to figure out how to do simple formatting stuff in Latex! It’s a good excuse for procrastinating though… I can always tell myself… \quote{this is for my thesis}… and worry about the “ACTUAL” content of the thesis  later .

I’m voicing my frustrations in my blog instead since the only living thing I’ve communicated in person so far for the past 5 days is my husband …  I’ve been living like a hermit (with a husband :-O) and is expecting to be one for the next N-months. Anyway, for those planning to write their thesis soon, just some hints and tips which I can offer for now… The next tips will come soon… when I’m still sane enough to blog by then…

\begin{itemize}

\item Make an outline (major chapters, possible subsections, a possible summary of contents, keywords, questions that you want to be answered at the end of the chapter)

\item Discuss your outline with your adviser… he/she might not like what you have so far, and may have valuable ideas that you need to incorporate in your thesis. After all, he/she is the one who should be pleased enough when reading your thesis (and possibly the only one who will be reading it anyway hehehe).

\item Re-write your outline

\item Write an initial abstract. This will most likely change when you’re done with writing your first draft. Re-write it again after the first draft… then re-write after the second draft… and so on and so forth.

\item Write an introduction that contains: the motivation for your work (why the hell are you doing it?), the goals and contributions of your work (assuming you have one… hopefully you do… or else…), a summary of the chapters (hopefully, this is not the only part your reviewers will read…)

\item Re-write your outline again… this time, try to incorporate some of the stuff you have written so far to the chapters you have foreseen your thesis will contain. This may be old publications, notes and other ideas you have scribbled on a napkin while  eating at Mc Donalds.

\end{itemize}

Well… that’s all I can share for now…

Have a nice weekend everyone!

*by the way, the crazy scripts are just examples of latex commands

export PATH = $PATH:[add new path here]

• by convention, environment variables are all uppercase
• values are COLON (:) separated
• this is only valid for a certain terminal session. To create a more permanent runtime configuration, follow the instruction on [this link]

Examples (taken from reference):

Reference: http://macdevcenter.com/pub/a/mac/2004/02/24/bash.html?page=last

Editing the /etc/paths file

• go to the /etc/ directory
• edit the paths file
  • sudo vi paths

Adding path files to the /etc/paths.d directory

• go to the /etc/paths.d directory
• create a file (e.g. myExes)
  • sudo vi myExes
• edit file and add the directory path (e.g. /Developer/myExes)
• save

Reference: http://docstore.mik.ua/orelly/xml/schema/ch12_01.htm

How to Declare Elements with Attributes and Values

Reference: http://www.learn-xml-schema-tutorial.com/Attributes.cfm

Suppose we want the definition for the following:

<FirstName Full="false">Nat</FirstName>

The XSD schema is:

 <xs:element name="FirstName">
        <xs:complexType>
         <xs:simpleContent>
          <xs:extension base="xs:string">
           <xs:attribute name="Full" type="xs:boolean"/>
          </xs:extension>
         </xs:simpleContent>
        </xs:complexType>
       </xs:element>

How to Reference Another XSD File from another XSD File

Reference: http://www.w3schools.com/schema/el_include.asp
Example:

<?xml version="1.0"?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3schools.com/schema"> 
<xs:include schemaLocation="http://www.w3schools.com/schema/customer.xsd"/>
 <xs:include schemaLocation="http://www.w3schools.com/schema/company.xsd"/>

How to extend Existing Types

Reference: http://www.codeproject.com/KB/cpp/XSDTutorial_03.aspx
Example:

<xs:complexType name="UKAddressType">

    <xs:complexContent>
        <xs:extension base="AddressType"> 
            <xs:sequence>
                <xs:element name="County" type="xs:string"/>
                <xs:element name="Postcode" type="xs:string"/>
            </xs:sequence>
        </xs:extension>
    </xs:complexContent>
</xs:complexType>

<xs:complexType name="USAddressType">
    <xs:complexContent>
        <xs:extension base="AddressType"> 
            <xs:sequence>
                <xs:element name="State" type="xs:string"/>
                <xs:element name="Zipcode" type="xs:string"/>
            </xs:sequence>
        </xs:extension>
    </xs:complexContent>
</xs:complexType>

How to do Restrictions

Reference: http://www.w3schools.com/schema/schema_facets.asp

Example: Restrictions on Values

 <xs:minInclusive value="0"/>
 <xs:maxInclusive value="120"/><xs:restriction base="xs:integer">
 </xs:restriction>
<xs:simpleType>
 </xs:simpleType>
<xs:element name="age">
 </xs:element>

Derivation by Extension of Complex Types

Use xsd:type

Declaring Abstract Elements

Reference: http://www.xfront.com/ElementHierarchy.html
Example:

Create an abstract element, and then create elements that are substitutable for it.

<xsd:element name="Publication" abstract="true"
             type="PublicationType"/>

<xsd:element name="Book" substitutionGroup="Publication"
             type="BookType"/>
<xsd:element name="Magazine" substitutionGroup="Publication"
             type="MagazineType"/>

where BookType and MagazineType both derive from PublicationType:

            PublicationType
              /         \
          BookType   MagazineType

The variable content container then is declared to contain the abstract element:

<xsd:element name="Catalogue">
    <xsd:complexType>
        <xsd:sequence>
            <xsd:element ref="Publication" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>
</xsd:element>

Thus, the contents of <Catalogue> can be any element that is in the substitution group with Publication. Here’s a sample instance document:

<Catalogue>
    <Book>...</Book>
    <Magazine>...</Magazine>
    <Book>...</Book>
</Catalogue>

How to Redefine Existing Types when using Include:

File1.xsd:

<xs:simpleType name="MobiaTypeSensorConfigProperty">....

File2.xsd:

<xs:redefine schemaLocation="File1.xsd">  
 <xs:simpleType name="MobiaTypeSensorConfigProperty">
 <xs:restriction base="MobiaTypeSensorConfigProperty">
  ....(the new definition here)
 </xs:restriction>            
 </xs:simpleType>
 </xs:redefine>

http://wiki.netbeans.org/IntroAndroidDevNetBeans

HOW TO…

• How to access the dialer via Intents
  • http://stuffthathappens.com/blog/2008/11/19/accessing-the-dialer/
• How to send SMS, email, etc.
  • http://mobiforge.com/developing/story/sms-messaging-android
• How to send email, sms, etc.
  • http://www.itwizard.ro/how-to-create-a-new-android-activity-82.html
• Running Tasks in Background Thread
  • http://developerlife.com/tutorials/?p=290

Frequently Used Android APIs (link to docs)

• Activity
  • http://developer.android.com/reference/android/app/Activity.html
• Intent
  • http://developer.android.com/reference/android/content/Intent.html

A core model is made up of

• EClass
  • contains: EAttributes, EReferences, EOperations
• EPackage
  • may contain: EDatatTypes, EEnums

Anotating Java Interfaces with @model

Syntax:

/**
 * @model [ property="value" | property="value" ] ...
 */

Notes:

• The Java source code specified does not need to be complete
• The code only needs enough information to describe the model
• Example
  • You need to provide Java interface FOR EACH EClass, BUT do not need to provide the implementation class
  • You need to provide a get() method FOR EACH attribute and reference, but do not need to do it for other accessor methods

Java Specification

Package

• Name with Suffix Package
• NOT  preceded by @model
• Attributes (String)
  • eName
  • eNS_URI
  • eNS_PREFIX

Example (Package):

public interface MOBIAPPPackage {

 String eNAME = "mobiapp";
 String eNS_URI = "http:///com/example/mobiapp.ecore";
 String eNS_PREFIX = "com.example.mobiapp";
}

Classes

EClass

• An EClass is specified by creating any Java Interface with the @model tag

EAttribute

• An EAttribute is specified as an accessor method
  • must precede with @model tag
  • name begins with get
  • if the return type of the method is booean, must begin with is
  • character after get|is must be uppercase
    • the name of the attribute is derived from the name of the method and the uppercase is converted to lowercase

Example (Class and Attributes)

/**
 * @model abstract="true" interface="false"
 * Maps to an abstract class named AndroidActivity
 */
public interface AndroidActivity {

 //EAttributes
 /**
 * @model
 */
 String getActivityName();
 ....

EReference

• An EReference is specified as a method in the interface corresponding to the EClass that contains the attribute
  • should be preceded by @model tag
  • does NOT include property called PARAMETERS
  • name begins with get followed by an uppercase character
  • return type is an EClass
    • if not, then it should be a List or EList, in which case, the eType of the EReference must be specified as part of the @model tag and upperbound of the eReference is set to -1

Example (Reference)

/**
 * @model abstract="true" interface="false"
 * Maps to an abstract class named AndroidActivity
 */
public interface AndroidActivity {

 //EAttributes
 /**
 * @model
 */
 String getActivityName();

 //EReferences
 /**
 * @model
 */
 AndroidActivity getNextActivity();
...

EOperation

• An EOperation is specified as a method in the Java interface
  • must precede with @model tag
  • @model tag has a property called parameters OR the method name does not conform to the EAttribute or EReference patterns
  • name of the EOperation is the same name as the method
  • the eType reference of the operation is the EClass or EDataType that corresponds to the return type of the Java method

Example (Reference and Operation)

/**
 * @model abstract="true" interface="false"
 * Maps to an abstract class named AndroidActivity
 */
public interface AndroidActivity {

 //EAttributes
 /**
 * @model
 */
 String getActivityName();

 //EReferences
 /**
 * @model
 */
 AndroidActivity getNextActivity();
 
 //EOperations
 //Automatic creation of EDatatype by EMF
 /**
 * @model parameters="android.os.Bundle"
 */
 void onCreate(android.os.Bundle savedInstanceState);

OR
//Explicit creation of EDataType (see next section)
 /**
 * @model parameters="emf.mode.android.Bundle"
 */
 void onCreate(Bundle savedInstanceState);
}

Data Types*

• EDataTypes can be EXPLICITLY defined in the java specification of the model
• HOWEVER, you usually don’t need to do this since EMF will automatically create an EDataType whenever any attribute or operation in the Java specification makes use of a data type that has not been explicitly defined in the model or in ECore
• When to define explicitly
  • when there is an existing EDataType corresponding to a Java type for which you wished to provide an alternate serialization format
• To Define
  • precede with the @model tag
  • return type of the method is EDataType
  • name of the method begins with get

Example (Data Types)

public interface ANDROIDPackage {

 String eNAME = "android";
 String eNS_URI = "http:///emf/model/android.ecore";
 String eNS_PREFIX = "emf.model.android";

 /**
 * @model instanceClass="android.os.Bundle
 */
 EDataType getBundle();
}

Enumerations

• any FINAL STATIC class declaration in your Java package is preceded by a @model tag is mapped to EEnum
• eLiterals reference for the EEnum is constructed from the list of EEnumLiterals that are derived from the fields that belong to the Java class

Example (Enumerations)

/**
 * @model
 */
public final class ActivityStatus extends AbstractEnumerator {

 /**
 * @model name="Started"
 */
 public static final int started = 0;

 /**
 * @model name="Running"
 */
 public static final int running = 1;

 /**
 * @model name="Pause"
 */
 public static final int pause = 2;

 /**
 * @model name="Shutdown"
 */
 public static final int shutdown = 3;
}

What’s next?

After defining the model using Java annotated code, proceed with generating the Ecore model

STEP 1: Right-click on SRC folder and choose New-> Other…

Step 2: Choose Eclipse Modeling Framework -> EMF Model and then press Next

Step 3: Choose which folder the sources are from and write the desired name for the model (suffix with .genmodel) and then press Next

Step 4: Choose where the model was created from. In this case, choose Annotated Java, then press Next

Step 5: Specify the package to generate and then press Finish

The generated Files

After doing the steps above, the following files are generated

• a .ecore file
• a .genmodel file

The generated files

As mentioned before (http://confessionsofastrugglingresearcher.wordpress.com/2009/06/08/emf-generating-code-overview/)

• The .genmodel is
  • where all the data needed by the EMF code generator is stored
  • It is itself an EMF model
  • It is tightly bounded to the Ecore model -> Generator model classes are decorators Ecore classes
    • defn: The decorator pattern can be used to make it possible to extend (decorate) the functionality of a class at runtime. This works by adding a new decorator class that wraps the original class.
  • Relevance of separating the Ecore model to the Generator Model
    • makes the Ecore model pure and independent of any information that is only relevant for code generation

The Ecore Output

The GenModel Output

Reference

• Eclipse Modeling Framework (A Developer’s Guide): http://www.informit.com/store/product.aspx?isbn=0131425420

1. Download Eclipse Modeling Tools
2. Create a project using EMF Project Wizard
3. [Create the model]
   
4. Select Generate Model Code from Menu

Generated Model Classes

• The EClass (Ecore class)

• • is equivalent to two classes in Java
    • a Java interface class
      • extends the base interface EObject (equivalent to Java’s Object class)
    • a Java implementation class

• The EObject interface

  • has the following methods
    • eClass()
      • returns the object’s metaobject (an EClass)
    • eContainer() and eResource()
      • returns the object’s containing object and resource
    • eGet(), eSet(), eIsSet(), eUnset()
      • provide an API for accessing the objects reflectively
  • extends from another interface called Notifier

• The Notifier

  • introduces an important characteristic to a modeled object which is the model change notification as in the Observer Design Pattern (defn: a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods).

• The Factory

  • Includes a create method for each class in the model

• The Package

  • Provides convenient accessors for all the Ecore metadata for the model

(Optional) Other Generated “Stuff”

• A skeleton adapter factory class
• A switch class that implements a “switch statement”-like callback mechanism for dispatching based on an object’s type
• A plug-in manifest file (so that the model can be used as an Eclipse plugin)
• An XML-schema for the model

@Generated (Regenerate Me!)

This Javadoc marker is used to identify generated parts. Without this tag, those part of the code will be left alone.

/**
 * @generated
 */
public String someMethod(){...

The Generator Model (.genmodel file)

• This is where all the data needed by the EMF code generator is stored
• It is itself an EMF model
• It is tightly bounded to the Ecore model -> Generator model classes are decorators Ecore classes
  • defn: The decorator pattern can be used to make it possible to extend (decorate) the functionality of a class at runtime. This works by adding a new decorator class that wraps the original class.
• Relevance of separating the Ecore model to the Generator Model
  • makes the Ecore model pure and independent of any information that is only relevant for code generation

Advantages of EMF Generated code

• clean, simple and efficient
• does not pull in large base classes or generate inefficient code

References:

• http://www.eclipse.org/modeling/emf/
• Eclipse Modeling Framework (A Developer’s Guide): http://www.informit.com/store/product.aspx?isbn=0131425420
• Download for Eclipse Modeling Tools – http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/ganymede/SR2/eclipse-modeling-ganymede-SR2-incubation-win32.zip
• http://en.wikipedia.org/wiki/Observer_pattern
• http://en.wikipedia.org/wiki/Decorator_pattern
• http://en.wikipedia.org/wiki/Reflection_API