CU-MCA-Mobile Applications Development Second draft-converted

/do your code bring valid back; default: return super.onOptionsItemSelected(item); } } } we are abrogating onCreateOptionsMenu() strategy in movement to make choices menu and stacked characterized menu asset utilizing MenuInflater.inflate(). By and large, during the dispatch of our action, onCreate() callback technique will be called by the android structure to get the necessary format for an action. At the point when we run the above model, we will get an outcome like as demonstrated beneath. Figure 7.3 Output of Android Options Menu Example Source: Tutlane.com This is how we can create Options Menu in android applications to handle global functionalities in our application. 151 CU IDOL SELF LEARNING MATERIAL (SLM)

7.3 CONTEXT MENU Context Menu is sort of a floating menu which appears when the user performs an extended press or click on a component and it's useful to implement actions that affect the chosen content or context frame. The android Context Menu is more just like the menu which displayed on right-click in Windows or Linux. Following is the pictorial representation of using Context Menu in our android applications. Figure 7.4. Representation of using Context Menu In android, the Context Menu gives movements that have an effect on a selected object or context body withinside the UI and we are able to offer a context menu for any view. The context menu won’t guide any object shortcuts and object icons. Create Android Context Menu in Activity The perspectives which we used to expose the context menu on long-press, we want to sign in that perspectives the use of registerForContextMenu(View) in our interest and we want to override onCreateContextMenu() in our interest or fragment. When the registered view gets a protracted click on occasion, the gadget calls our onCreateContextMenu() approach. By the use of the onCreateContextMenu() approach, we are able to create our menu gadgets as proven below. @Override 152 covered void onCreate(Bundle savedInstanceState) format.activity_main); Button btn = (Button) findViewById(R.id.btnShow); registerForContextMenu(btn); } @Override CU IDOL SELF LEARNING MATERIAL (SLM)

public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfomenuInfo) look at above code, we registered our Button manage the use of registerForContextMenu() to expose the context menu on button long-click on and binding the Context Menu gadgets the use of the onCreateContextMenu() approach. Handle Android Context Menu Click Events In android, we are able to manage a context menu object click on occasions with the use of the onContextItemSelected() approach. For an example of coping with a context menu object click on occasion the use of onContextItemSelected() approach. @Override public boolean onContextItemSelected(MenuItem object) { if (object.getTitle() == \"Save\") else go back false; } go back true; } Android Context Menu Example Example of enforcing a Context Menu withinside the android utility. Create a brand new android utility the use of android studio and provide names as ContextMenuExample Now open an activity_main.xml document from the res layout course and write the code like as proven below activity_main.xml If you look at the above code we created one Button manage withinside the XML Layout document to expose the context menu whilst we do a protracted press at the Button. Once we're performed with the introduction of format with required manage, we want to load the XML format aid from our interest onCreate() callback approach, for that open most important interest document MainActivity.java from and write the code like as proven below. 153 CU IDOL SELF LEARNING MATERIAL (SLM)

MainActivity.java import android.guide.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.ContextMenu; import android.view.MenuItem; import android.view.View; import android.widget.Button; import android.widget.Toast; public elegance MainActivity extends AppCompatActivity { @Override covered void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.format.activity_main); Button btn = (Button) findViewById(R.id.btnShow); registerForContextMenu(btn); } @Override public void onCreateContextMenu(ContextMenu menu, View v, \" +object.getTitle(), ContextMenu.ContextMenuInfomenuInfo) @Override public boolean onContextItemSelected(MenuItem object) { Toast.makeText(this, \"Selected Item: Toast.LENGTH_SHORT).show(); go back true; } } If you look at the above code we're overriding onCreateContextMenu() approach in interest to create context menu and registered view for context menu the use of registerForContextMenu(). 154 CU IDOL SELF LEARNING MATERIAL (SLM)

Generally, all through the release of our interest, the onCreate() callback approach may be known as via way of means of the android framework to get the desired format for an interest. The output of Android Context Menu Example When we run the above instance with the use of an android digital device (AVD) we are able to get an end result like as proven below. Figure 7.5. Output of Android Context Menu 7.4 POPUP MENU Android Popup Menu presentations the menu beneath the anchor textual content if the area is to be had in any other case above the anchor textual content. It disappears in case you click on outside the popup menu. The android.widget.PopupMenu is subclass of java.lang.Object class. Android Popup Menu Example Let's see the way to create a popup menu in android. activity_main.xml It carries the simplest one button. File: activity_main.xml popup_menu.xml 155 CU IDOL SELF LEARNING MATERIAL (SLM)

Activity class 156 It displays the popup menu on clicking the button. File: MainActivity.java package deal example.jst.com.popupmenu; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.MenuItem; import android.view.View; import android.widget.Button; import android.widget.PopupMenu; import android.widget.Toast; public class MainActivity extends AppCompatActivity { Button button; @Override {protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); button = (Button) findViewById(R.id.button); button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { //Creating {the instance of PopupMenu PopupMenu popup = new PopupMenu(MainActivity.this, button); //Inflating the Popup the use of xml file CU IDOL SELF LEARNING MATERIAL (SLM)

popup.getMenuInflater().inflate(R.menu.popup_menu, popup.getMenu()); //registering popup with OnMenuItemClickListener popup.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() { public boolean onMenuItemClick(MenuItem item) { Toast.makeText(MainActivity.this,\"You Clicked : \" + item.getTitle(), Toast.LENGTH_SHORT).display(); return true; } }); popup.display();//displaying popup menu } });//closing the setOnClickListener method } } ________________________________________ Output: 157 CU IDOL SELF LEARNING MATERIAL (SLM)

Figure 7.5. Output of Popup Menu 158 CU IDOL SELF LEARNING MATERIAL (SLM)

7.5 TABBED MENU Tabs at the moment are satisfactorily applied with the aid of using leveraging the ViewPager with a custom \"tab indicator\" on top. we can be the use Google's new TabLayout withinside the help layout library launch for Android \"M\". Prior to Android \"M\", the perfect manner to install tabs with Fragments became to apply ActionBar Tabs as defined in ActionBar Tabs with Fragments guide. However, all techniques associated with navigation modes withinside the ActionBar class (along with setNavigationMode(), addTab(), selectTab(), etc.) at the moment are deprecated. Setup To enforce Google Play fashion sliding tabs, ensure to feature the Material Design Components Library. In your root build.gradle, ensure the google() access is listed: all projects } Add this dependency on your app/build.gradle list: dependencies Sliding Tabs Layout Simply upload com.google.android.material.tabs.TabLayout, on the way to be used for rendering the special tab options. The android.viewpager.widget.ViewPager can be used to web page among the diverse fragments . Create Fragment Now that we've the ViewPager and our tabs in our format, we must begin defining the content of every of the tabs. Since every tab is only a fragment being displayed, we want to create and outline the Fragment to be shown. You may also have one or extra fragments on your software relying on your requirements. In res/layout/fragment_page.xml outline the XML layout for the fragment on the way to be displayed on display while a selected tab is selected: In PageFragment.java outline the inflation good judgment for the fragment of tab content: // In this case, the fragment shows easy textual content primarily based totally on the web page publicclassPageFragmentextends Fragment { public static final String ARG_PAGE = \"ARG_PAGE\"; 159 CU IDOL SELF LEARNING MATERIAL (SLM)

privateintmPage; publicstaticPageFragmentnewInstance(int page){ Bundle args=newBundle(); args.putInt(ARG_PAGE, page); PageFragment fragment =newPageFragment(); fragment.setArguments(args); return fragment; } @Override publicvoidonCreate(Bundle savedInstanceState) @Override public View onCreateView(LayoutInflater inflater,ViewGroup container, Bundle savedInstanceState){ View view=inflater.inflate(R.layout.fragment_page, container,false); TextViewtextView=(TextView) view; textView.setText(\"Fragment #\" +mPage); return view; } } Implement FragmentPagerAdapter The subsequent aspect to do is to enforce the adapter in your ViewPager which controls the order of the tabs, the titles, and their related content material. The maximum critical techniques to enforce right here are getPageTitle(int position) which's used to get the identity for every tab and getItem(int position) which determines the fragment for every tab. publicclassSampleFragmentPagerAdapterextendsFragmentPagerAdapter finalint PAGE_COUNT = 3; {private String tabTitles[]=new String[]; non-public Context context; 160 CU IDOL SELF LEARNING MATERIAL (SLM)

publicSampleFragmentPagerAdapter(FragmentManagerfm, Context context) @Override publicintgetCount(){ return PAGE_COUNT; } @Override public Fragment getItem(int position) @Override publicCharSequencegetPageTitle(int position){ // Generate identify primarily based totally on object position returntabTitles[position]; } } Setup Sliding Tabs Finally, we want to connect our ViewPager to the SampleFragmentPagerAdapter after which configure the sliding tabs with a two-step process: • In the onCreate() approach of your activity, locate the ViewPager and join the adapter. • Set the ViewPager at the TabLayout to attach the pager with the tabs. publicclassMainActivityextendsAppCompatActivity{ @Override protectedvoidonCreate(Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Get the ViewPager and set it is PagerAdapter in order that it may show items 161 CU IDOL SELF LEARNING MATERIAL (SLM)

ViewPagerviewPager=(ViewPager)findViewById(R.id.viewpager); viewPager.setAdapter(newSampleFragmentPagerAdapter(getSupportFragmentManager(), MainActivity.this)); // Give the TabLayout the ViewPager TabLayouttabLayout=(TabLayout)findViewById(R.id.sliding_tabs); tabLayout.setupWithViewPager(viewPager); } } Here the output: Figure 7.6. Sliding Tab Demo Resource: Tutlane.com 7.6 SUMMARY In android, the Menu is a critical part of the UI factor that is used to offer a few not unusual place capabilities across the utility. With the assist of the menu, customers can revel in a clean and regular revel in during the utility. 162 CU IDOL SELF LEARNING MATERIAL (SLM)

In order to apply the menu, we have to outline it in a separate XML record and use that record in our utility primarily based totally on our requirements. Also, we are able to use menu APIs to symbolize consumer movements and different alternatives in our android utility activities. There are 3 kinds of menus in Android: Popup, Contextual, and Options. Each one has a selected use case and code that is going alongside it. To discover ways to use them, study on. Each menu should have an XML record associated with it which defines its layout. These are the tags related to the menu option: • <menu> - This is the container element for your menu (similar to LinearLayout) • <item> - This denotes an item and is nested inside of the menu tag. Be aware that an item element can hold a <menu> element to represent a submenu • <group> - This is used to signify a certain property or feature to a couple of menu items (I.E. state/visibility) • Nested classes • interface • PopupMenu.OnDismissListener • Callback interface used to notify the application that the menu has closed. • interface • PopupMenu.OnMenuItemClickListener • Interface responsible for receiving menu item click events if the items themselves do not have individual item click listeners. • usually create a new class that implements the interface and subclasses an existing class 7.7 KEYWORDS • Options Menu- This is the primary set of menu items for an Activity. It is revealed by pressing the device MENU keyContext Menu • Icon Menu- This is the collection of items initially visible at the bottom of the screen at the press of the MENU key. • Expanded Menu- This is a vertical list of items exposed by the \"More\" menu item from the Icon Menu. 163 CU IDOL SELF LEARNING MATERIAL (SLM)

• Context Menu- This is a floating list of menu items that may appear when you perform a long-press on a View (such as a list item). • Submenu- This is a floating list of menu items that is revealed by an item in the Options Menu or a Context Menu. 7.8 LEARNING ACTIVITY 1. Write an app to create an Option Menu having two options: one for launching a new Activity and another for closing the current Activity. ___________________________________________________________________________ ___________________________________________________________________ 7.9UNIT END QUESTIONS A. Descriptive Questions Short Questions 1. Explain Options Menu. 2. Explain Icon Menu. 3. Explain Context Menu. 4. Define Submenu. 5. Define format manager. Long Questions 1. What is adapter class? 2. What is the gain of the usage of format managers? 3. What are the exclusive styles of format manager? 4. What is the system is used for converting the format manager? 5. What styles of menus is/are supported through Android? B. Multiple Choice Questions 1. What types of menus is/are supported by Android? a. Option menu and Context menu b. Only Option menu c. Only Context menu d. None of these 2. Action Bar Can Be Associated To 164 CU IDOL SELF LEARNING MATERIAL (SLM)

a. Only Fragments b. Only Activities c. Both Activities And Fragments d. None of these 3. Which of the following is not a valid Android resource filename? a. mylayout.xml b. myLayout.xml c. my_layout.xml d. mylayout1.xml 4. To display text which control you will use? a. EditText b. TextView c. label d. None of these 5. Which of the important device characteristics that you should consider as you design and develop your application? a. screen size and density b. input configurations c. device features d.All of these Answers 1-a, 2-b, 3-a, 4-b,5-d 7.10 REFERENCES Reference Books ● Khoshafian, et al. (1990). Object orientation: Concepts, Languages, Databases. New York: John Wiley & Sons 165 CU IDOL SELF LEARNING MATERIAL (SLM)

● Thornsby, J. (May 2016). Android UI Design. Packt Publishing. ● Morris, J. (Feb 2011). Android User Interface Development - Beginner’s Guide. UK. Packt Publishing Websites • https://enos.itcollege.ee/~jpoial/allalaadimised/reading/Android-UI-Design.pdf • https://www.techotopia.com/index.php/Understanding_Android_Views,_View_Gr oups_and_Layouts • https://www.tutorialspoint.com/software_architecture_design/user_interface.htm • https://www.wideskills.com/android/building-user-interface/listening-to-ui- notifications-in-android • https://developer.android.com/guide/fragments/lifecycle 166 CU IDOL SELF LEARNING MATERIAL (SLM)

UNIT - 8: ANDROID ALARM,DRAG AND DROP ACTIVITY Structure 8.0.Learning Objectives 8.1.Introduction 8.2.Android Alarm Manager 8.3.Drag and Drop Activity 8.3.1.The Drag Drop Process 8.3.2.Drag Event Class. 8.4.Summary 8.5.Keywords 8.6.Learning Activity 8.7.Unit End Questions 8.8.References 8.0LEARNING OBJECTIVES After studying this unit, you will be able to: • Explain Implementation of Android Alaram Manager • Explain implementing Android Drag and Drop functionality in our application. • Apply Android Framework built-in mechanism for implementing Drag and drop feature in an application. • Describe Attempt Drag Drop Process • Explain usage of Drag Event Class 8.1 INTRODUCTION Public class AlarmManager extends Object java.lang.Object ↳ android.app.AlarmManager This class offers get entry to device alarm services. These assist you to agenda your software to be run in some unspecified time in the future withinside the future. When an alarm is going off, the Intent that have been registered for it's far broadcast through the device, mechanically beginning the goal software if it isn't already strolling. Registered alarms are retained even as the tool is asleep (and might optionally wake the tool up in the event that they burst off at some point of that time), however can be cleared if it's far grew to become off and rebooted. 167 CU IDOL SELF LEARNING MATERIAL (SLM)

The Alarm Manager holds a CPU wake lock so long as the alarm receiver's onReceive() approach is executing. This ensures that the telecellsmartphone will now no longer sleep till you've got completed managing the published. Once onReceive() returns, the Alarm Manager releases this wake lock. This way that the telecellsmartphone will in a few cases sleep as quickly as your onReceive() method completes. If your alarm receiver known as Context.startService(), it's far viable that the telecellsmartphone will sleep earlier than the asked provider is launched. To save you this, your BroadcastReceiver and Service will want to put in force a separate wake lock coverage to make sure that the telecellsmartphone maintains strolling till the service will become available. The drag/drop process. In reaction to the person's gesture to start a drag, your software calls startDrag() to inform the device to begin a drag. The arguments startDrag() offer the data to be dragged, metadata for this statistics, and a callback for drawing the drag shadow. 8.2ANDROID ALARM MANAGER Android AlarmManager permits you to get right of entry to the gadget alarm. With the assist of Android AlarmManager in android, you may time table your utility to run at a particular time withinside the future. It works whether or not your phone is jogging or now no longer. The Android AlarmManager holds a CPU wake lock that offers a assure now no longer to sleep the telecellsmartphone till the published is handled. Android AlarmManager Example Let's see an easy AlarmManager instance that runs after a particular time supplied through the user. activity_main.xml You want to drag best aedittext and a button as given below. File: activity_main.xml 168 <?xml version=\"1.0\" encoding=\"utf-8\"?> <RelativeLayout xmlns:android=\"http://schemas.android.com/apk/res/android\" xmlns:app=\"http://schemas.android.com/apk/res-auto\" xmlns:tools=\"http://schemas.android.com/tools\" android:layout_width=\"match_parent\" android:layout_height=\"match_parent\" tools:context=\"example.jst.com.alarmmanager.MainActivity\"> CU IDOL SELF LEARNING MATERIAL (SLM)

<Button 169 android:id=\"@+id/button\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:text=\"Start\" android:layout_alignParentBottom=\"true\" android:layout_centerHorizontal=\"true\" android:layout_marginBottom=\"103dp\" /> <EditText android:id=\"@+id/time\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignParentTop=\"true\" android:layout_centerHorizontal=\"true\" android:layout_marginTop=\"22dp\" android:ems=\"10\" /> </RelativeLayout> Activity class The activity class starts the alarm service when user clicks on the button. File: MainActivity.java package example.jst.com.alarmmanager; import android.app.AlarmManager; import android.app.PendingIntent; import android.content.Intent; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; CU IDOL SELF LEARNING MATERIAL (SLM)

import android.view.View; import android.widget.Button; import android.widget.EditText; import android.widget.Toast; public class MainActivity extends AppCompatActivity { Button start; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); start= findViewById(R.id.button); start.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { startAlert(); } }); } public void startAlert(){ EditText text = findViewById(R.id.time); int i = Integer.parseInt(text.getText().toString()); Intent intent = new Intent(this, MyBroadcastReceiver.class); PendingIntent pendingIntent = PendingIntent.getBroadcast( this.getApplicationContext(), 234324243, intent, 0); AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVIC E); alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() 170 CU IDOL SELF LEARNING MATERIAL (SLM)

+ (i * 1000), pendingIntent); Toast.makeText(this, \"Alarm set in \" + i + \" seconds\",Toast.LENGTH_LONG).show(); } } Let's create BroadcastReceiver class that starts alarm. File: MyBroadcastReceiver.java package example.jst.com.alarmmanager; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.media.MediaPlayer; import android.widget.Toast; public class MyBroadcastReceiver extends BroadcastReceiver { MediaPlayer mp; @Override public void onReceive(Context context, Intent intent) { mp=MediaPlayer.create(context, R.raw.alarm); mp.start(); Toast.makeText(context, \"Alarm....\", Toast.LENGTH_LONG).show(); } } File: AndroidManifest.xml 171 You need to provide a receiver entry in AndroidManifest.xml file. <receiver android:name=\"MyBroadcastReceiver\" > </receiver> Let's see the full code of AndroidManifest.xml file. <?xml version=\"1.0\" encoding=\"utf-8\"?> CU IDOL SELF LEARNING MATERIAL (SLM)

<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\" package=\"example.jst.com.alarmmanager\"> <application android:allowBackup=\"true\" android:icon=\"@mipmap/ic_launcher\" android:label=\"@string/app_name\" android:roundIcon=\"@mipmap/ic_launcher_round\" android:supportsRtl=\"true\" android:theme=\"@style/AppTheme\"> <activity android:name=\".MainActivity\"> <intent-filter> <action android:name=\"android.intent.action.MAIN\" /> <category android:name=\"android.intent.category.LAUNCHER\" /> </intent-filter> </activity> <receiver android:name=\"MyBroadcastReceiver\" > </receiver> </application> </manifest> Figure 8.1. Output of AlarnManager 172 CU IDOL SELF LEARNING MATERIAL (SLM)

8.3 DRAG AND DROP ACTIVITY The Drag and Drop framework permits customers to transport records from one view to every other the usage of a graphical drag and drop gesture. The Drag and Drop framework will encompass the subsequent functionalities to aid the records motion in android applications. • Drag Event Class • Drag Listeners • Helper Methods and Classes Generally, the Drag and Drop procedure begins offevolved whilst customers making gestures diagnosed as a sign to begin dragging records and the software tells the device that the drag is beginning. Once the drag is beginning, the device name-lower back to our software to get the kingdom of records being dragged and it sends drag occasions to the drag occasion listeners or call- back techniques of every View withinside the format. 8.3.1 The Drag Drop Process The Drag and Drop procedure includes four steps or states: • Started • Continuing • Dropped • Ended Started This occasion will arise whilst we begin dragging an object in format and our software will name the startDrag() technique to inform the device to begin a drag. The startDrag() technique arguments will offer records to be dragged, metadata for this records, and a name- lower back for drawing the drag shadow. The device will reply lower back to our software to get a drag shadow and it's going to show the drag shadow at the device. 173 CU IDOL SELF LEARNING MATERIAL (SLM)

After that, the device will ship a drag occasion with motion kind ACTION_DRAG_STARTED to the drag occasion listeners for all of the View items withinside the modern format. To obtain drag occasions continuously, inclusive of a likely drop occasion, the drag occasion listener should go back proper and it registers the listener with the device due to the fact handiest registered listeners retain to obtain drag occasions. At this point, listeners also can alternate the arrival in their View item to reveal that the listener can receive a drop occasion. In case if the drag occasion listener returns false, then it won’t obtain any drag occasions for the modern operation till the device sends a drag occasion with motion kind ACTION_DRAG_ENDED. By sending false, the listener tells the device that it isn't always inquisitive about the drag operation and does now no longer need to just accept the dragged records. Continuing When the person maintains to drag, the drag shadow intersects with the bounding field of a View item and the device sends one or greater drag occasions to the View item's drag occasion listener (In case if it's far registered to obtain occasions). In reaction to the occasion, the listener might also additionally select to adjust its View item’s appearance. For example, if the occasion suggests that the drag shadow has entered the bounding field of the View (motion kind ACTION_DRAG_ENTERED), the listener can react with the aid of using highlighting its View. Dropped Whenever the person releases the drag shadow in the bounding field of a View that could receive the records. The device sends the View item's listener a drag occasion with action type ACTION_DROP. The drag occasion will incorporate the records this is handed to the device even as beginning the operation with the aid of using the usage of the startDrag() technique and the listener will go back proper to the device in case it drops success. Ended After finishing touch of motion kind ACTION_DROP, the device sends out a drag occasion with motion kind ACTION_DRAG_ENDED to suggest that the drag operation is over. This is executed no matter wherein the person launched the drag shadow. 174 CU IDOL SELF LEARNING MATERIAL (SLM)

8.3.2 Drag Event Class The DragEvent represents an occasion this is despatched out with the aid of using the device at diverse instances all through a drag and drop operation. This elegance offers few Constants and vital techniques which we use all through the Drag/Drop procedure. Constants Following are all constants integers to be had as part of DragEvent elegance. Sr.No. Constants & Description ACTION_DRAG_STARTED 1 Signals the start of a drag and drop operation. ACTION_DRAG_ENTERED 2 Signals to a View that the drag point has entered the bounding box of the View. ACTION_DRAG_LOCATION 3 Sent to a View after ACTION_DRAG_ENTERED if the drag shadow is still within the View object's bounding box. ACTION_DRAG_EXITED 4 Signals that the user has moved the drag shadow outside the bounding box of the View. ACTION_DROP 5 Signals to a View that the user has released the drag shadow, and the drag point is within the bounding box of the View. ACTION_DRAG_ENDED 6 Signals to a View that the drag and drop operation has concluded. Table 8.1 Methods - DragEvent elegance Following are few important and most frequently used methods available as a part of DragEvent class. Sr.No. Constants & Description int getAction() 1 Inspect the action value of this event.. 175 CU IDOL SELF LEARNING MATERIAL (SLM)

ClipDatagetClipData() 2 Returns the ClipData object sent to the system as part of the call to startDrag(). ClipDescriptiongetClipDescription() 3 Returns the ClipDescription object contained in the ClipData. booleangetResult() 4 Returns an indication of the result of the drag and drop operation. float getX() 5 Gets the X coordinate of the drag point. float getY() 6 Gets the Y coordinate of the drag point. String toString() 7 Returns a string representation of this DragEvent object. Table 8.2 Method - DragEvent class. 8.4 SUMMARY • Android drag/drop structure permits your clients to move information starting with one View then onto the next View in the current format utilizing a graphical simplified motion. As of API 11 intuitive of view onto different perspectives or view, bunches are upheld. The system incorporates the accompanying three significant parts to help drag and drop usefulness – • Drag event class. • Drag listeners. • Helper methods and classes. • The Drag/Drop Process • There are essentially four stages or stages in the simplified interaction − • Started − This occasion happens when you begin hauling a thing in a format, your application calls the startDrag() strategy to advise the framework to begin a drag. The contentions inside the startDrag() technique give the information to be hauled, metadata for this information, and a callback for drawing the drag shadow. • The framework initially reacts by getting back to back to your application to get a drag shadow. It at that point shows the drag shadow on the gadget. • Then, the framework sends a drag occasion with activity type ACTION_DRAG_STARTED to the enlisted drag occasion audience members for all the View objects in the current format. 176 CU IDOL SELF LEARNING MATERIAL (SLM)

• To keep on accepting drag occasions, including a potential drop occasion, a drag occasion audience should return valid, If the drag occasion audience returns bogus, at that point it won't get drag occasions for the current activity until the framework sends a drag occasion with activity type ACTION_DRAG_ENDED. • Continuing − The client proceeds with the drag. The framework sends ACTION_DRAG_ENTERED activity followed by ACTION_DRAG_LOCATION activity to the enlisted drag occasion audience for the View where hauling point enters. The audience may decide to adjust its View item's appearance in light of the occasion or can respond by featuring its View. • The drag occasion audience gets an ACTION_DRAG_EXITED activity after the client has moved the drag shadow outside the jumping box of the View. • Dropped − The client delivers the hauled thing inside the bouncing box of a View. The framework sends the View article's audience a drag occasion with activity type ACTION_DROP. • Ended − Just after the activity type ACTION_DROP, the framework conveys a drag occasion with activity type ACTION_DRAG_ENDED to demonstrate that the drag activity is finished. • A simplified activity begins when the client makes some motion that you perceive as a sign to begin hauling information. Accordingly, your application tells the framework that the drag is beginning. The framework gets back to your application to get a portrayal of the information being hauled. As the client's finger moves this portrayal (a \"drag shadow\") over the current format, the framework sends drag occasions to the drag occasion audience articles and drag occasion callback techniques related with the View objects. 8.5 KEYWORDS • Android Alarm Manager- android.app.AlarmManager. This class provides access to the system alarm services. • Drag and Drop - is a pointing device gesture in which the user selects a virtual object by \"grabbing\" it and dragging it to a different location or onto another virtual object. • Started − This event occurs when you start dragging an item in a layout, your application calls startDrag() method to tell the system to start a drag. ... • Continuing − The user continues the drag. ... • Dropped − The user releases the dragged item within the bounding box of a View. 8.6 LEARNING ACTIVITY 1. Drag and drop a textual content view from one area to some other in a bounding region and this bounding region is half of the screen. 177 CU IDOL SELF LEARNING MATERIAL (SLM)

___________________________________________________________________________ ___________________________________________________________________ 2. Create a timer that reminds the person to get up each 15 mins.Stand Up! is an app that allows you live healthful through reminding you to get up and stroll round each 15 mins. It makes use of a notification to permit you to recognize whilst 15 mins have passed. The app consists of a toggle button which could flip the alarm on and off. ___________________________________________________________________________ ___________________________________________________________________ Figure 8.2. Alarm reminder 178 8.7 UNIT END QUESTIONS A. Descriptive Questions Short Questions 1. Drag and Drop. 2. Android alert. 3. Event class 4. Alarm manager 5. Use of Alarm manager Long Questions CU IDOL SELF LEARNING MATERIAL (SLM)

1. How to execute Drag and Drop utilizing DragLinearLayout in Android 2. What is android caution administrator? 3. How to carry out android alert supervisor? 4. Explain parts to help drag and drop usefulness. 5. Explain Drag Event Class. B. Multiple Choice Questions 1. Which event is fired as the mouse is moving over an element when a drag is occurring? a. dragover b. dragenter c. dragstart d. dragleave 2. The _________ event is fired on the element where the drop occurred at the end of the drag operation. a. drag b. drop c. dragstart d. dragenter 3. A listener for the dragenter and dragover events are used to indicate valid drop targets, that is, places where dragged items may be dropped. a. True b. False 4. What types of User Notifications are provided by Android? a. Toast Messages. b. Tabs. c. Notification Area Notifications. d. Dialogs. e. Fragments. 5. A type of service provided by android that shows messages and alerts to user is _____ a. Content Providers 179 CU IDOL SELF LEARNING MATERIAL (SLM)

b. View System c. Notifications Manager d. Activity Manager Answers 1-a, 2-b, 3-a, 4-a,5-c 8.8 REFERENCES Reference Books ● Khoshafian, et al. (1990). Object orientation: Concepts, Languages, Databases. New York: John Wiley & Sons ● Thornsby, J. (May 2016). Android UI Design. Packt Publishing. ● Morris, J. (Feb 2011). Android User Interface Development - Beginner’s Guide. UK. Packt Publishing Websites • https://enos.itcollege.ee/~jpoial/allalaadimised/reading/Android-UI-Design.pdf • https://www.techotopia.com/index.php/Understanding_Android_Views,_View_Gr oups_and_Layouts • https://www.tutorialspoint.com/software_architecture_design/user_interface.htm • https://www.wideskills.com/android/building-user-interface/listening-to-ui- notifications-in-android • https://developer.android.com/guide/fragments/lifecycle 180 CU IDOL SELF LEARNING MATERIAL (SLM)

UNIT - 9: MULTIMEDIA Structure 9.0.Learning Objectives 9.1. Introduction 9.2. 2D/3D Graphics (Layout/Canvas Drawing) 9.3. Audio 9.4. Video 9.5. Recording Media 9.6. Speech API 9.7. Telephony API 9.8. Send Mail 9.9. Send SMS 9.10. Summary 9.11. Keywords 9.12. Learning Activity 9.13. Unit End Questions 9.14. References 9.0LEARNING OBJECTIVES After studying this unit, you will be able to: • Explain audio player • Describe video player • Implementof audio recording player • Illustrate working with Speech API • Describe Telephony API • Implement Sending Mail • Describe the use SMS facilty 9.1 INTRODUCTION The Android sight and sound system incorporates support for playing an assortment of normal media types so you can without much of a stretch coordinate sound, video, and pictures into your applications. You can play sound or video from media records put away in your application's assets (crude assets), from independent documents in the filesystem, or from an information transfer showing up over an organization association, all utilizing Media Player APIs. This archive tells you the best way to utilize MediaPlayer to compose a media-playing application that collaborates with the client and the framework to get great execution and a 181 CU IDOL SELF LEARNING MATERIAL (SLM)

charming client experience. On the other hand, you should utilize ExoPlayer, which is an adaptable open-source library that upholds superior highlights not accessible in MediaPlayer. 9.22D/3D GRAPHICS (LAYOUT/CANVAS DRAWING) When composing an application, it's critical to consider precisely what your graphical requests will be. Fluctuating graphical assignments are best refined with shifting procedures. For instance, illustrations and activitys for a preferably static application ought to be executed a lot of contrastingly over designs and livelinesss for an intelligent game. Here, we'll examine a couple of the choices you have for drawing illustrations on Android and which undertakings they're most appropriate for. Material and Drawables Android gives a bunch of View gadgets that give general usefulness to a wide cluster of UIs. You can likewise stretch out these gadgets to adjust the manner in which they look or act. Likewise, you can do your own custom 2D delivering utilizing the different drawing techniques contained in the Canvas class or make Drawable items for things, for example, finished fastens or edge by-outline activitys. Equipment Acceleration Starting in Android 3.0, you would hardware be able to speed up most of the drawing done by the Canvas APIs to additional expansion their presentation. OpenGL Android upholds OpenGL ES 1.0 and 2.0, with Android structure APIs just as locally with the Native Development Kit (NDK). Utilizing the system APIs is desirable when you need to add a couple of graphical upgrades to your application that are not upheld with the Canvas APIs, or in the event that you want stage autonomy and don't request superior. There is an exhibition hit in utilizing the structure APIs contrasted with the NDK, so for some realistic serious applications like games, utilizing the NDK is gainful (It is essential to note however that you can in any case get sufficient execution utilizing the system APIs. For instance, the Google Body application is grown completely utilizing the system APIs). OpenGL with the NDK is additionally valuable on the off chance that you have a ton of local code that you need to port over to Android. For more data about utilizing the NDK, read the docs in the docs/catalogue of the NDK download. The Android system APIs gives a set 2D drawing APIs that permit you to deliver your own custom designs onto a material or to alter existing Views to modify their look and feel. When drawing 2D designs, you'll commonly do as such in one of two different ways: 182 CU IDOL SELF LEARNING MATERIAL (SLM)

1. Draw your designs or movements into a View object from your format. Thusly, the drawing of your illustrations is dealt with by the framework's typical View progression drawing measure — you basically characterize the designs to go inside the View. 2. Draw your illustrations straightforwardly to a Canvas. Thusly, you by and by call the fitting class' onDraw() technique (passing it your Canvas), or one of the Canvas draw...() strategies (likedrawPicture()). In doing as such, you are additionally in charge of any liveliness. Alternative \"a,\" attracting to a View, is your most ideal decision when you need to draw straightforward illustrations that don't have to change progressively and are not piece of a presentation serious game. For instance, you should bring your illustrations into a View when you need to show a static realistic or predefined movement, inside a generally static application. Peruse Drawables for more data. Alternative \"b,\" attracting to a Canvas, is better when your application needs to routinely re- draw itself. Applications, for example, computer games ought to draw the Canvas all alone. Nonetheless, there's more than one approach to do this: • In a similar string as your UI Activity, wherein you make a custom View part in your design, call nullify() and afterward handle the onDraw() callback. • Or, in a different string, wherein you deal with a SurfaceView and perform attracts to the Canvas however quick as your string may be skilled (you don't have to demand invalidate()). Draw with a Canvas At the point when you're composing an application in which you might want to perform particular drawing or potentially control the activity of illustrations, you ought to do as such by drawing through a Canvas. A Canvas works for you as an affectation, or interface, to the real surface whereupon your designs will be drawn — it holds the entirety of your \"draw\" calls. By means of the Canvas, your drawing is really performed upon a basic Bitmap, which is put into the window. In the occasion that you're drawing inside the onDraw() callback strategy, the Canvas is accommodated you and you need just spot your drawing calls upon it. You can likewise obtain a Canvas fromSurfaceHolder.lockCanvas() when managing a SurfaceView object. (Both of these situations are talked about in the accompanying areas.) However, assuming you need to make another Canvas, you should characterize the bitmap whereupon drawing will really be performed. The Bitmap is constantly needed for a Canvas. You can set up another Canvas this way: 183 CU IDOL SELF LEARNING MATERIAL (SLM)

Bitmap b = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888); Material c = new Canvas(b); Presently your Canvas will draw onto the characterized Bitmap. In the wake of drawing upon it with the Canvas, you would then be able to convey your Bitmap to another Canvas with one of the Canvas.drawBitmap(Bitmap,...) techniques. It's suggested that you eventually draw your last designs through a Canvas offered to you by View.onDraw()or SurfaceHolder.lockCanvas(). The Canvas class has its own arrangement of drawing strategies that you can utilize, as drawBitmap(...),drawRect(...), drawText(...), and some more. Different classes that you may utilize additionally have drawn ()techniques. For instance, you'll most likely have some Drawable articles that you need to put on the Canvas. Drawable has its own draw() strategy that accepts your Canvas as a contention. On a View In the event that your application doesn't need a lot of preparing or casing rate speed (maybe for a chess game, a snake game, or another gradually vivified application), at that point you ought to consider making a custom View segment and drawing with a Canvas in View.onDraw(). The most advantageous part of doing so is that the Android system will give you a pre-characterized Canvas to which you will put your drawing calls. To begin, expand the View class (or relative thereof) and characterize the onDraw() callback strategy. This technique will be called by the Android structure to demand that your View draw itself. This is the place where you will play out the entirety of your calls to draw through the Canvas, which is gone to you through the onDraw() callback. The Android structure will just call onDraw() as essential. Each time that your application is set up to be drawn, you should demand your View be negated by calling nullify(). This shows that you'd like your View to be drawn and Android will at that point call your onDraw() strategy (however isn't ensured that the callback will be quick). Inside your View segment's onDraw(), utilize the Canvas given to you for all your drawing, utilizing different Canvas. draw...() strategies, or another class draw () techniques that accept 184 CU IDOL SELF LEARNING MATERIAL (SLM)

your Canvas as a contention. When your onDraw() is finished, the Android structure will utilize your Canvas to draw a Bitmap took care of by the framework. Note: In request to demand an invalid from a string other than your fundamental Activity's string, you should call postInvalidate(). For an example application, see the Snake game, in the SDK tests envelope: <your-sdk- directory>/tests/Snake/. On a SurfaceView The SurfaceView is an uncommon subclass of View that offers a committed drawing surface inside the View chain of importance. The point is to offer this attracting surface to an application's auxiliary string so the application isn't needed to stand by until the framework's View chain of command is prepared to draw. All things considered, an auxiliary string that has reference to a SurfaceView can attract to its own Canvas at its own speed. To start, you need to make another class that expands SurfaceView. The class ought to likewise implementSurfaceHolder.Callback. This subclass is an interface that will tell you with data about the hidden Surface, for example, when it is made, changed, or obliterated. These occasions are significant with the goal that you know when you can begin drawing, regardless of whether you need to make changes dependent on new surface properties, and when to quit drawing and possibly execute a few errands. Inside your SurfaceView class is additionally a decent spot to characterize your auxiliary Thread class, which will play out all the attracting methods to your Canvas. Rather than taking care of the Surface item straightforwardly, you should deal with it through a SurfaceHolder. Along these lines, when your SurfaceView is instated, get the SurfaceHolder by calling getHolder(). You should then inform the SurfaceHolder that you'd prefer to get SurfaceHoldercallbacks (from SurfaceHolder.Callback) by calling addCallback() (pass it this). At that point supersede every one of the SurfaceHolder.Callback techniques inside your SurfaceView class. To attract to the Surface Canvas from inside your subsequent string, you should pass the string your SurfaceHandler and recover the Canvas with lockCanvas(). You would now be able to take the Canvas given to you by the SurfaceHolder and do your fundamental drawing 185 CU IDOL SELF LEARNING MATERIAL (SLM)

upon it. Whenever you're finished drawing with the Canvas, call unlockCanvasAndPost(), passing it your Canvas object. The Surface will presently draw the Canvas as you left it. Play out this arrangement of locking and opening the material each time you need to redraw. Note: On each pass, you recover the Canvas from the SurfaceHolder, the past condition of the Canvas will be held. To appropriately vivify your designs, you should re-paint the whole surface. For instance, you can get the past state free from the Canvas by filling in shading with drawColor() or setting a foundation picture with drawBitmap(). Else, you will see hints of the drawings you recently performed. For an example application, see the Lunar Lander game, in the SDK tests envelope: <your- sdk-directory>/tests/LunarLander/. Drawables Android offers a custom 2D designs library for drawing shapes and pictures. The android.graphics.drawable bundle is the place where you'll track down the normal classes utilized for attracting two measurements. This record examines the nuts and bolts of utilizing Drawable items to attract illustrations and how to two or three subclasses of the Drawable class. A Drawable is an overall deliberation for \"something that can be drawn.\" You'll find that the Drawable class stretches out to characterize an assortment of explicit sorts of drawable designs, including BitmapDrawable, ShapeDrawable, PictureDrawable, LayerDrawable, and a few more. Obviously, you can likewise stretch out these to characterize your own custom Drawable items that carry on extraordinarily. There are three different ways to characterize and start up a Drawable: utilizing a picture saved in your task assets; utilizing a XML record that characterizes the Drawable properties; or utilizing the typical class constructors. Beneath, we'll examine every one of the initial two strategies (utilizing constructors is the same old thing for an accomplished designer). Making from asset pictures A basic method to add designs to your application is by referring to a picture document from your venture assets. Upheld document types are PNG (liked), JPG (worthy), and GIF (debilitate). This strategy would clearly be liked for application symbols, logos, or different designs like those utilized in a game. 186 CU IDOL SELF LEARNING MATERIAL (SLM)

To utilize a picture asset, simply add your document to the res/drawable/index of your venture. From that point, you can reference it from your code or your XML design. In any case, it is alluded to utilizing an asset ID, which is the record name without the document type augmentation (E.g., my_image.png is referred to as my_image). Note: Image assets set in res/drawable/might be naturally streamlined with lossless picture pressure by the aapt apparatus during the form interaction. For instance, a real nature PNG that doesn't need in excess of 256 shadings might be changed over to a 8-cycle PNG with a shading range. This will bring about a picture of equivalent quality however which requires less memory. So know that the picture pairs put in this catalogue can change during the form. On the off chance that you plan on perusing a picture as a bitstream to change it over to a bitmap, put your pictures in the res/crude/organizer all things considered, where they won't be streamlined. Model code The accompanying code scrap shows how to construct an ImageView that utilizes a picture from drawable assets and adds it to the design. LinearLayoutmLinearLayout; secured void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); /Create a LinearLayout in which to add the ImageView mLinearLayout = new LinearLayout(this); /Instantiate an ImageView and characterize its properties ImageViewi = new ImageView(this); i.setImageResource(R.drawable.my_image); i.setAdjustViewBounds(true);/set the ImageView limits to coordinate with the Drawable's measurements i.setLayoutParams(new Gallery.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)); /Add the ImageView to the format and set the design as the substance see mLinearLayout.addView(i); setContentView(mLinearLayout); } In different cases, you might need to deal with your picture asset as a Drawable article. To do as such, make a Drawable from the asset like so: 187 CU IDOL SELF LEARNING MATERIAL (SLM)

Assets res = mContext.getResources(); Drawable myImage = res.getDrawable(R.drawable.my_image); Note: Each special asset in your undertaking can keep up just one express, regardless of the number of various articles you may launch for it. For instance, on the off chance that you start up two Drawable items from a similar picture asset, change a property (like the alpha) for one of the Drawables, at that point it will likewise influence the other. So when managing various occasions of a picture asset, rather than straightforwardly changing the Drawable, you ought to play out a tween activity. Model XML The XML bit beneath tells the best way to add an asset Drawable to an ImageView in the XML design (with some red color for no particular reason). <ImageView android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:tint=\"#55ff0000\" android:src=\"@drawable/my_image\"/> Creating from resource XML At this point, you ought to be comfortable with Android's standards of building up a User Interface. Henceforth, you comprehend the force and adaptability intrinsic in characterizing objects in XML. This way of thinking continues from Views to Drawables. In the event that there is a Drawable item that you'd prefer to make, which isn't at first ward on factors characterized by your application code or client association, at that point characterizing the Drawable in XML is a decent alternative. Regardless of whether you anticipate that your Drawable should change its properties during the client's involvement in your application, you ought to think about characterizing the item in XML, as you can generally alter properties whenever it is launched. Whenever you've characterized your Drawable in XML, save the document in the res/drawable/catalogue of your venture. At that point, recover and start up the item by calling Resources.getDrawable(), passing it the asset ID of your XML record. Any Drawable subclass that upholds the swell() strategy can be characterized in XML and started up by your application. Each Drawable that upholds XML expansion uses explicit XML ascribes that help characterize the article properties. Model 188 CU IDOL SELF LEARNING MATERIAL (SLM)

Here's some XML that characterizes a TransitionDrawable: <transition xmlns:android=\"http://schemas.android.com/apk/res/android\"> <item android:drawable=\"@drawable/image_expand\"> <item android:drawable=\"@drawable/image_collapse\"> </transition> With this XML saved in the record res/drawable/expand_collapse.xml, the accompanying code will launch the TransitionDrawable and set it as the substance of an ImageView: Assets res = mContext.getResources(); TransitionDrawable change = (TransitionDrawable) res.getDrawable(R.drawable.expand_collapse); ImageView picture = (ImageView) findViewById(R.id.toggle_image); image.setImageDrawable(transition); At that point this change can be run forward (for 1 second) with: transition.startTransition(1000); Allude to the Drawable classes recorded above for more data on the XML credits upheld by each. Shape Drawable At the point when you need to progressively draw some two-dimensional illustrations, a ShapeDrawable article will likely suit your requirements. With a ShapeDrawable, you can automatically draw crude shapes and style them in any capacity possible. A ShapeDrawable is an expansion of Drawable, so you can utilize one any place a Drawable is normal — maybe for the foundation of a View, set with setBackgroundDrawable(). Obviously, you can likewise draw your shape as its own custom View, to be added to your format anyway you please. Since the ShapeDrawable has its own draw() technique, you can make a subclass of View that draws the ShapeDrawable during the view.onDraw() strategy. Here's a fundamental expansion of the View class that does only this, to draw a ShapeDrawable as a View: public class CustomDrawableView broadens View { private ShapeDrawablemDrawable; public CustomDrawableView(Context setting) { super(context); int x = 10; int y = 10; int width = 300; 189 CU IDOL SELF LEARNING MATERIAL (SLM)

int tallness = 50; mDrawable = new ShapeDrawable(new OvalShape()); mDrawable.getPaint().setColor(0xff74AC23); mDrawable.setBounds(x, y, x + width, y + tallness); } secured void onDraw(Canvas material) { mDrawable.draw(canvas); }} In the constructor, a ShapeDrawable characterizes as an oval shape. It's at that point given a shading and the limits of the shape are set. In the event that you don't set the limits, the shape won't be drawn, though on the off chance that you don't set the shading, it will default to dark. With the custom View characterized, it very well may be drawn any way you like. With the example above, we can draw the shape automatically in an Activity: CustomDrawableViewmCustomDrawableView; secured void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mCustomDrawableView = new CustomDrawableView(this); setContentView(mCustomDrawableView); } In the event that you'd prefer to draw this custom drawable from the XML format rather than from the Activity, at that point the CustomDrawable class should supersede the View(Context, AttributeSet) constructor, which is called while starting up a View by means of expansion from XML. At that point add a CustomDrawable component to the XML, as so: <com.example1.shapedrawable.CustomDrawableView android:layout_width=\"fill_parent\" android:layout_height=\"wrap_content\" /> The ShapeDrawable class (in the same way as other Drawable sorts in the android.graphics.drawable bundle) permits you to characterize different properties of the drawable with public techniques. A few properties you should change incorporate alpha straightforwardness, shading channel, vacillate, murkiness, and shading. 190 CU IDOL SELF LEARNING MATERIAL (SLM)

9.3 AUDIO We can play and manage audio files on android with the help of the MediaPlayer section. Here, we will see a simple example of playing an audio file. MediaPlayer Category Android. media class.MediaPlayer is used to control audio or video files. MediaPlayer category methods There are many modes in the MediaPlayer category. Some of them are as follows: Method Description public void setDataSource(String path) sets the data source (file path or http url) to use. public void prepare() prepares the player for playback synchronously. public void start() it starts or resumes the playback. public void stop() it stops the playback. public void pause() it pauses the playback. public booleanisPlaying() checks if media player is playing. public void seekTo(int millis) seeks to specified time in miliseconds. public void setLooping(boolean looping) sets the player for looping or non- looping. public booleanisLooping() checks if the player is looping or non- looping. public void selectTrack(int index) it selects a track for the specified index. public int getCurrentPosition() returns the current playback position. public int getDuration() returns duration of the file. public void setVolume(float sets the volume on this player. leftVolume,floatrightVolume) Activity class Table 9.1 MediaPlayer category CU IDOL SELF LEARNING MATERIAL (SLM) 191

Code of to play the audio file. Here, we are going to play maie.mp3 file located inside the sdcard/Music directory. File: MainActivity package com.example1.audiomediaplayer1; import android.media.MediaPlayer; import android.net.Uri; import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.widget.MediaController; import android.widget.VideoView; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); MediaPlayer mp=new MediaPlayer(); try{ mp.setDataSource(\"/sdcard/Music/maine.mp3\");//Write your location here mp.prepare(); mp.start(); }catch(Exception e){e.printStackTrace();} } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it's present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } } 192 CU IDOL SELF LEARNING MATERIAL (SLM)

MediaPlayer Example of controlling the audio Example to start out , stop and pause the audio play. activity_main.xml Drag three buttons from pallete to start out , stop and pause the audio play. Now the xml file will look like this: File: MainActivity.java <Button 193 android:id=\"@+id/button1\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignLeft=\"@+id/textView1\" android:layout_below=\"@+id/textView1\" android:layout_marginTop=\"48dp\" android:text=\"start\" /> <Button android:id=\"@+id/button2\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignTop=\"@+id/button1\" android:layout_toRightOf=\"@+id/button1\" android:text=\"pause\" /> <Button android:id=\"@+id/button3\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignTop=\"@+id/button2\" android:layout_toRightOf=\"@+id/button2\" android:text=\"stop\" /> CU IDOL SELF LEARNING MATERIAL (SLM)

Activity class Code to start, pause and stop the audio player. File: MainActivity.java package com.example1.audioplay; import android.media.MediaPlayer; import android.os.Bundle; import android.os.Environment; import android.app.Activity; import android.view.Menu; import android.view.View; import android.view.View.(Button)findViewById(R.id.button1); pause=(Button)findViewById(R.id.button2); stop=(Button)findViewById(R.id.button3); //creating media player final MediaPlayer mp=new MediaPlayer(); try{ //you can change the trail , here path is external directory(e.g. sdcard) /Music/maine.mp3 mp.setDataSource(Environment.getExternalStorageDirectory().getPath()+\"/Music/maine.mp 3\"); mp.prepare(); }catch(Exception e){e.printStackTrace();} start.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { mp.start(); } }); pause.setOnClickListener(new OnClickListener() { @Override 194 CU IDOL SELF LEARNING MATERIAL (SLM)

public void onClick(View v) { mp.pause(); } }); stop.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { mp.stop(); } }); } } Output: Figure 9.1. Audio Play Output 9.4 VIDEO we can play the video files on android, With the help of MediaController and VideoView classes. MediaController class media controls eg. play/pause, previous, next, fast/ forward, rewind, etc are in the android.widget.MediaController as view . 195 CU IDOL SELF LEARNING MATERIAL (SLM)

VideoView class methods to play and control the video player are provided by the android. widget.VideoView class. The commonly used methods of VideoView class are as follows: Method Description public void setMediaController(MediaController sets the media controller to the video controller) view. public void setVideoURI (Uri uri) sets the URI of the video file. public void start() starts the video view. public void stopPlayback() stops the playback. public void pause() pauses the playback. public void suspend() suspends the playback. public void resume() resumes the playback. public void seekTo(int millis) seeks to specified time in miliseconds. Table 9.2 Methods of VideoView class activity_main.xml Select the VideoView from the pallete : File: activity_main.xml <RelativeLayout xmlns:androclass=\"http://schemas.android.com/apk/res/android\" xmlns:tools=\"http://schemas.android.com/tools\" android:layout_height=\"match_parent\" 196 android:layout_width=\"match_parent\" CU IDOL SELF LEARNING MATERIAL (SLM)

tools:context=\".MainActivity\" > 197 <VideoView android:id=\"@+id/videoView1\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignParentLeft=\"true\" android:layout_centerVertical=\"true\" /> </RelativeLayout> Activity class Code of to play the video file. File: MainActivity.java package com.example1.video1; import android.net.Uri; import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.widget.MediaController; import android.widget.VideoView; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); CU IDOL SELF LEARNING MATERIAL (SLM)

VideoView videoView =(VideoView)findViewById(R.id.videoView1); //Creating MediaController MediaController mediaController= new MediaController(this); mediaController.setAnchorView(videoView); //specify the location of media file Uri uri=Uri.parse(Environment.getExternalStorageDirectory().getPath()+\"/media/1.mp4\"); //Setting MediaController and URI, then starting the videoView videoView.setMediaController(mediaController); videoView.setVideoURI(uri); videoView.requestFocus(); videoView.start(); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } } 9.5 RECORDING MEDIA MediaRecorder class can be used to record audio and video files. we can create a sound file that can be played later, after recording the media. 198 CU IDOL SELF LEARNING MATERIAL (SLM)

In this example, we are going to record the audio file and store it in the external directory in 3gp format. activity_main.xml Drag 2 buttons, one to start the recording, another to stop the recording. File: activity_main.xml <RelativeLayoutxmlns:androclass=\"http://schemas.android.com/apk/res/android\" xmlns:tools=\"http://schemas.android.com/tools\" android:layout_height=\"match_parent\" android:layout_width=\"match_parent\" android:paddingBottom=\"@dimen/activity_vertical_margin\" android:paddingLeft=\"@dimen/activity_horizontal_margin\" android:paddingRight=\"@dimen/activity_horizontal_margin\" android:paddingTop=\"@dimen/activity_vertical_margin\" tools:context=\".MainActivity\" > <Button 199 android:id=\"@+id/button1\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignParentLeft=\"true\" android:layout_alignParentTop=\"true\" android:layout_marginLeft=\"68dp\" android:layout_marginTop=\"50dp\" android:text=\"Start Recording\" android:onClick=\"startRecording\" /> CU IDOL SELF LEARNING MATERIAL (SLM)

<Button 200 android:id=\"@+id/button2\" android:layout_width=\"wrap_content\" android:layout_height=\"wrap_content\" android:layout_alignLeft=\"@+id/button1\" android:layout_below=\"@+id/button1\" android:layout_marginTop=\"64dp\" android:text=\"Stop Recording\" android:onClick=\"stopRecording\" /> </RelativeLayout> Activity class File: MainActivity.java package com.jst.mediarecorder; import java.io.File; import java.io.IOException; import android.app.Activity; import android.content.ContentResolver; import android.content.ContentValues; import android.content.Intent; import android.media.MediaRecorder; import android.net.Uri; import android.os.Bundle; import android.os.Environment; import android.provider.MediaStore; import android.util.Log; CU IDOL SELF LEARNING MATERIAL (SLM)