If you are ready with API key and device token you can use the below code
to send
push notification to a android device
try {
String androidFcmKey="XXXXXXXXXXXX";
String androidFcmUrl="https://fcm.googleapis.com/fcm/send";
RestTemplate restTemplate = new RestTemplate();
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.set("Authorization", "key=" + androidFcmKey);
httpHeaders.set("Content-Type", "application/json");
JSONObject msg = new JSONObject();
JSONObject json = new JSONObject();
msg.put("title", "Title");
msg.put("body", "Message");
msg.put("notificationType", "Test");
json.put("data", msg);
json.put("to", deviceToken);
HttpEntity<String> httpEntity = new
HttpEntity<String>(json.toString(),httpHeaders);
String response =
restTemplate.postForObject(androidFcmUrl,httpEntity,String.class);
System.out.println(response);
} catch (JSONException e) {
e.printStackTrace();
}
sender id :A unique numerical value created when you configure your API project.
The sender ID is used in the registration process to identify an app server that is
permitted to send messages to the client app.
Server key A key saved on the app server that gives the app server authorized
access to Google services. In HTTP, the server key is included in the header of
POST requests that send messages.
Application id : The client app that is registering to receive messages. How this
is implemented is platform-dependent:
Android: use the package name from the app manifest.
iOS: use the app's bundle identifier.
Chrome: use the Chrome extension name.
Registration Token An ID issued by the GCM connection servers to the client
app that allows it to receive messages. Note that registration tokens must be kept
secret.
android SDK manager
emulator to run our android app
android 2.2 covers most of all devices...
activity is nothing but section or page of your application..
activity can be home page or about page or we can say page of website, screen where
user interact
store in project folder @---android category folder , res --- layout folder
activity_main.xml
AVD manager --- android virtual device manager -- nexus5 to set default device
emulator HAXM required to run AVD
to solve this just run exe from the path of android sdk path having intel hardware
accelator
intelhaxm-android (2 gb)
geny motion emulator -- its FAST emulator
install geny motion plugin
studio has widgets
manifest folder -- main launcher having entry of all activities will have action
tag with acitivty package name
super class is activity
new activity will create activity xml and java file...
new java class called intent
create instance of intent
Intent intent = new Intent("activityname with package")
startActivity(intent) -- open acitivity by intent method
button_sbm = (Button) findViewById(R.id.button)
setOnClickListener(){
new View.OnClickListener(){
public void onClick(View v){
AlertDialog.Builder
just like message dialog or alert box in javascript
DialogInterface
}
}
resource has values folder to define string constants in strings.xml
drawable folder to store image asset
image type high dpi, mdpi,xhdpi,
layout /activity
setContentView(R.layout.activity_main)
ListView
adapter to add data to view
ArrayAdapter
seekbar -- progress bar
WebView -- like browser
webview.loadUrl(url)
android gestures..
android libraries --- android.view.MotionEvent
android.gesture.Gesture
android.view.GestureDetector
interface to implement MainActivity class ---
GestureDetector.OnGestureListener
GestureDetector.onDoubleTapListener
GestureDetectorCompat
onDoubleTap, onSingleTap
Android fragments ---
portion of UI on screen like portal...
layout linear layout, framelayout, table laoyout, relative layout
fragment manager help us to handle fragments
SQLite, a lightweight relational database, is used for data storage purposes.
Google Cloud Messaging (GCM) is a service that lets developers send short message
data to their users on Android devices,
core Android libraries available to the Android developer is as follows -
-----------------------------------------------------------------------
android.app - Provides access to the application model and is the cornerstone
of all Android applications.
android.content - Facilitates content access, publishing and messaging between
applications and application components.
android.database - Used to access data published by content providers and
includes SQLite database management classes.
android.opengl - A Java interface to the OpenGL ES 3D graphics rendering API.
android.os - Provides applications with access to standard operating system
services including messages, system services and inter-process communication.
android.text - Used to render and manipulate text on a device display.
android.view - The fundamental building blocks of application user interfaces.
android.widget - A rich collection of pre-built user interface components such
as buttons, labels, list views, layout managers, radio buttons etc.
android.webkit - A set of classes intended to allow web-browsing capabilities
to be built into applications.
Dalvik Virtual Machine which is a kind of Java Virtual Machine specially designed
and optimized for Android.
Android framework includes the following key services -
Activity Manager - Controls all aspects of the application lifecycle and
activity stack.
Content Providers - Allows applications to publish and share data with other
applications.
Resource Manager - Provides access to non-code embedded resources such as
strings, color settings and user interface layouts.
Notifications Manager - Allows applications to display alerts and notifications
to the user.
View System - An extensible set of views used to create application user
interfaces.
components are loosely coupled by the application manifest file AndroidManifest.xml
that describes each component of the application and how they interact.
4 main component of application:
Activities : They dictate the UI and handle the user interaction to the smart phone
screen.
Services: They handle background processing associated with an application.
Broadcast Receivers: They handle communication between Android OS and applications.
Content Providers: They handle data and database management issues.
Activity performs actions on the screen. For example, an email application might
have one activity that shows a list of new emails, another activity to compose an
email, and another activity for reading emails.
A service is a component that runs in the background to perform long-running
operations.
public class MyService extends Service {
}
public class MyReceiver extends BroadcastReceiver {
public void onReceive(context,intent){}
}
A content provider component supplies data from one application to others on
request.
public class MyContentProvider extends ContentProvider {
public void onCreate(){}
}
fragments, views, layouts, intents, resources, manifest...
select the form factors your application runs on, here need to specify Minimum SDK,
in our tutorial, I have declared as API23: Android 6.0(Mashmallow) -- target
android devices...
MainActivity.java source file having an activity class that runs when your app is
launched using the app icon.
layout/
XML files that define a user interface layout. They are saved in res/layout/ and
accessed from the R.layout class.
A service is a component that runs in the background to perform long-running
operations without needing to interact with the user and it works even if
application is destroyed. A service can essentially take two states -
content provider component supplies data from one application to others on
request....ContentResolver class....
defined content provider URI address which will be used to access the content...
content://contacts/people/5
SQLite database
Finally register your Content Provider in your activity file using <provider> tag.
// Add a new student record
ContentValues values = new ContentValues();
values.put(StudentsProvider.NAME,
((EditText)findViewById(R.id.editText2)).getText().toString());
values.put(StudentsProvider.GRADE,
((EditText)findViewById(R.id.editText3)).getText().toString());
Uri uri = getContentResolver().insert(
StudentsProvider.CONTENT_URI, values);
Toast.makeText(getBaseContext(),
uri.toString(), Toast.LENGTH_LONG).show();
on retrieve
String URL = "content://com.example.MyApplication.StudentsProvider";
Uri students = Uri.parse(URL);
Cursor c = managedQuery(students, null, null, null, "name");
if (c.moveToFirst()) {
do{
Toast.makeText(this,
c.getString(c.getColumnIndex(StudentsProvider._ID)) +
", " + c.getString(c.getColumnIndex( StudentsProvider.NAME)) +
", " + c.getString(c.getColumnIndex( StudentsProvider.GRADE)),
Toast.LENGTH_SHORT).show();
} while (c.moveToNext());
}
}
A fragment has its own layout and its own behaviour with its own life cycle
callbacks.
create fragments by extending Fragment class and You can insert a fragment into
your activity layout by declaring the fragment in the activity's layout file, as a
<fragment> element.
fragment give more flexibiilty. divide device screen and control different parts
separately.
broadcastIntent to send it to any interested BroadcastReceiver components
an Intent object, is a passive data structure holding an abstract description of an
operation to be performed.
let's assume that you have an Activity that needs to launch an email client and
sends an email using your Android device. For this purpose, your Activity would
send an ACTION_SEND along with appropriate chooser, to the Android Intent Resolver
ACTION_SEND intent is to send an email..
assume that you have an Activity that needs to open URL in a web browser on your
Android device. For this purpose, your Activity will send
ACTION_WEB_SEARCH Intent to the Android Intent Resolver to open given URL in the
web browser.
String q = "tutorialspoint"
Intent intent = new Intent(Intent.ACTION_WEB_SEARCH );
intent.putExtra(SearchManager.QUERY, q);
startActivity(intent);
Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
email.putExtra(Intent.EXTRA_EMAIL, recipients);
email.putExtra(Intent.EXTRA_SUBJECT, subject.getText().toString());
email.putExtra(Intent.EXTRA_TEXT, body.getText().toString());
startActivity(Intent.createChooser(email, "Choose an email client from..."));
mechanisms for delivering intents to each type of component - activities, services,
and broadcast receivers.
An Intent object is a bundle of information which is used by the component that
receives the intent as well as information used by the Android system
intent is passed to startActivity, startService, sendBroadcast()
action -- mandatory part of an intent object
important Android Intent Standard Actions
ACTION_CALL_BUTTON -- to go to dialer or appropriate UI for placing a call
ACTION_CAMERA_BUTTON -- camera button was presseds
ACTION_DIAL: Dial a number as specified by the data.
ACTION_GTALK_SERVICE_DISCONNECTED
A GTalk connection has been disconnected.
ACTION_INSTALL_PACKAGE : Launch application installer.
ACTION_SEND:
Deliver some data to someone else.
View is the base class for widgets, which are used to create interactive UI
components like buttons, text fields, etc.
you can declare your layout using simple XML file main_layout.xml which is located
in the res/layout folder of your project.
A View is an object that draws something on the screen that the user can interact
Toast class provides a handy way to show users alerts but problem is that these
alerts are not persistent
flashes for few seconds...
simple way to create a notification.
As a first step is to create a notification builder using
NotificationCompat.Builder.build().
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
mBuilder.setSmallIcon(R.drawable.notification_icon);
mBuilder.setContentTitle("Notification Alert, Click Me!");
mBuilder.setContentText("Hi, This is Android Notification Detail!");
Attach Actions to notifications so when user clicks on notification it will dirctly
go to activity in your application.
action is defined by a PendingIntent
pass the Notification object to the system by calling NotificationManager.notify()
to send your notification
layout file for new activity
location tracking, geofencing, and activity recognition.
Location object represents a geographic location which can consist of a latitude,
longitude,
location client which is LocationClient object, connect it to Location Services
using connect() method, and then call its getLastLocation() method. This method
returns the most recent location in the form of Location object that contains
latitude and longitude coordinates
callback method is called when location service is connected to the location client
successfully. You will use connect() method to connect to the location client
Geocoder.getFromLocation() method to get an address for a given latitude and
longitude
SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage("phoneNo", null, "sms message", null, null);
or
Intent sendIntent = new Intent(Intent.ACTION_VIEW);
sendIntent.putExtra("sms_body", "default content");
sendIntent.setType("vnd.android-dir/mms-sms");
startActivity(sendIntent);
smsIntent.putExtra("address" , new String("0123456789;3393993300"));
smsIntent.putExtra("sms_body" , "Test SMS to Angilla")
startActivity(smsIntent);
finish();
Intent phoneIntent = new Intent(Intent.ACTION_CALL);
phoneIntent.setData(Uri.parse("tel:91-000-000-0000"));
startActivity(callIntent);
Intent callIntent = new Intent(Intent.ACTION_CALL);
callIntent.setData(Uri.parse("tel:0377778888"));
Android application publishing is a process that makes your Android applications
available to users. Infect, publishing is the last phase of the Android application
development process.
maximum size for an APK published on Google Play is 50 MB. can have extension file
if size is bigger.
Dx tools(Dalvik executable tools ): It going to convert .class file to .dex
file. it has useful for memory optimization and reduce the boot-up speed time
AAPT(Android assistance packaging tool):it has useful to convert .Dex file
to.Apk
APK(Android packaging kit): The final stage of deployment process is called
as .apk.
Build ? Generate Signed APK from your Android studio
