Mobile Application Development

It is used in 80% of the smartphones in the world.

All of the code is open to the developers for customization.

Android is used in smartphones, smart watches, TVs and cars.

Vendors can tailor Android to specific hardware or user needs.

• Detects device orientation, motion and speed.

• Measures angular rotation.
• Used in steering in games.

• Detects the user’s geographic position.

• Detects how close the user’s face is.
• This disables the screen during phone calls.

• This contains all static data which is to be separated from the code.
• Includes:
  • XML Layouts (stored in res/layout/)
  • Strings
  • Images
  • Colors
  • Media Files

• These are the executable of an app.
• These includes:

• Every layer in this stack, uses services of the layer below, to serve the layer above.
• The linux kernel is responsible for low-level memory management and security features.
• The kernel talks to the hardware directly, and hardware abstraction layer makes accessing hardware more abstract and standardized.
• Native C/C++ libraries (Android Native Development Kit, or NDK) or Android Runtime (ART), do all the backend work involved in an app. These include managing databases, graphics, web rendering engines, and in basic system functions too.
• The Java API Framework consists of premade classes which correspond to different parts of an app.

• A configuration file that the Android Runtime reads first.
• This declares all of the components of the App.

• Manages dependencies and build settings using the .gradle config files.
• It also manages APK (Android Package) versions.

• A Java Class that serves as a controller for a specific screen, is called an activity.
• Such a Java Class must extend Activity (basic activity lifecycle features provided here) or extend AppCompatActivity (this is preferred because modern Android features are backported to older versions too). AppCompatActivity extends FragmentActivity which extends ComponentActivity which extends Activity.
• The screen that the app starts with, is controlled with the help of the MainActivity.java file.

• It is a set of states an activity can be in during it’s lifetime, from when it is created until it is destroyed.
• It’s a graph where the nodes are the states, the edges are the callbacks.
  • Created (not visible yet)
  • Started (visible)
  • Resume (In foreground and interactive)
  • Paused(partially invisible)
  • Stopped (hidden)
  • Destroyed (gone from memory)

Let’s arbitrarily take the <TextView/> view and study its properties defined in XML.

<TextView
       android:id="@+id/nameOfID"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:background="@color/myBackgroundColor"
       android:text="@string/count_initial_value"
       android:textColor="@color/#0000aa"
       android:textSize="@dimen/count_text_size"
       android:gravity="center"
       android:textAlignment="center"
       android:textStyle="bold" 
       android:autoLink="web"
/>

• The three ways to define a view is:
  • Graphically
  • Through XML
  • Programmatically
• A constraint represents connection or alignment to another view.

• A ViewGroup is a type of View that can contain other Views.
• You can see the View Hierarchy in the component tree.
  • Use the smallest number of simplest views
  • Keep the view hierarchy flat by limiting nesting of views.

• Layout is a type of ViewGroup that are designed to position and arrange those views on the screen.

• This is the intent used to transfer from one activity to another activity within an application.
• Right click on the app and create a new activity (Android Studio will automatically create and link the XML file).

• Trigger the new activity by setting onClick parameter of a button as the name of a function doSomething(), which is a void function defined in MainActivity.

  public void doSomething(View view){
      Intent intent = new Intent(this, Next.class);
      intent.putExtra("answer", String.valueOf(Integer.parseInt(someInput.getText().toString()) +100));
      // in case you're using data instead of extras (both explained later):
      // intent.setData(Uri.parse("http://www.google.com"));
      startActivity(intent);
  }
  
  

  where someInput is the id of an EditText object.

• And in the new activity’s onCreate() function:

  Intent intent = getIntent();
  textView = (TextView) findViewById(R.id.textView);
  textView.setText(String.valueOf(intent.getStringExtra("answer")));
  
  

• This is used to invoke an activity from another app.
• Here the system is asked to find an activity that can handle this request.

    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        super.onSaveInstanceState(outState);
        // the below line is what you add
        outState.putString("topic", feedbackTopic.getText().toString());
    }

When you rotate the screen, the state of an activity is destroyed. This is the function that’s called just before the activity is destroyed.

    @Override
    protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        // the below line is what you add
        feedbackTopic.setText(savedInstanceState.getString("topic"));
    }

This is the function that is called when the activity is recreated after the screen rotates.