Android - aparat
Oto dwa sposoby wykorzystania aparatu w aplikacji
Korzystanie z istniejącej aplikacji aparatu Android w naszej aplikacji
Bezpośrednio przy użyciu Camera API dostarczanego przez system Android w naszej aplikacji
Korzystanie z istniejącej aplikacji aparatu Android w naszej aplikacji
Użyjesz MediaStore.ACTION_IMAGE_CAPTURE do uruchomienia istniejącej aplikacji aparatu zainstalowanej w telefonie. Jego składnię podano poniżej
Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);Oprócz powyższego dostępne są inne intencje dostarczone przez MediaStore. Są one wymienione w następujący sposób
| Sr.No | Rodzaj i opis intencji |
|---|---|
| 1 | ACTION_IMAGE_CAPTURE_SECURE Zwraca obraz przechwycony z aparatu, gdy urządzenie jest zabezpieczone |
| 2 | ACTION_VIDEO_CAPTURE Wywołuje istniejącą aplikację wideo w systemie Android do przechwytywania wideo |
| 3 | EXTRA_SCREEN_ORIENTATION Służy do ustawiania orientacji ekranu na pionową lub poziomą |
| 4 | EXTRA_FULL_SCREEN Służy do sterowania interfejsem użytkownika ViewImage |
| 5 | INTENT_ACTION_VIDEO_CAMERA Ta intencja służy do uruchamiania aparatu w trybie wideo |
| 6 | EXTRA_SIZE_LIMIT Służy do określenia limitu rozmiaru wideo lub rozmiaru przechwytywania obrazu |
Teraz użyjesz funkcji startActivityForResult () do uruchomienia tego działania i zaczekania na jego wynik. Jego składnię podano poniżej
startActivityForResult(intent,0)Ta metoda została zdefiniowana w activityklasa. Wzywamy to z głównej działalności. Istnieją metody zdefiniowane w klasie działania, które wykonują to samo zadanie, ale są używane, gdy dzwonisz nie z działania, ale z innego miejsca. Są one wymienione poniżej
| Sr.No | Opis funkcji działania |
|---|---|
| 1 | startActivityForResult(Intent intent, int requestCode, Bundle options) Rozpoczyna działanie, ale może wymagać dodatkowego pakietu opcji |
| 2 | startActivityFromChild(Activity child, Intent intent, int requestCode) Uruchamia działanie, gdy Twoja aktywność jest pochodną jakiejkolwiek innej czynności |
| 3 | startActivityFromChild(Activity child, Intent intent, int requestCode, Bundle options) Działa tak samo jak powyżej, ale może przybierać dodatkowe wartości w postaci wiązki |
| 4 | startActivityFromFragment(Fragment fragment, Intent intent, int requestCode) Uruchamia aktywność od fragmentu, w którym aktualnie się znajdujesz |
| 5 | startActivityFromFragment(Fragment fragment, Intent intent, int requestCode, Bundle options) Nie tylko uruchamia działanie z fragmentu, ale może przybierać z nim dodatkowe wartości |
Niezależnie od funkcji użytej do uruchomienia działania wszystkie zwracają wynik. Wynik można uzyskać, zastępując funkcję onActivityResult .
Przykład
Oto przykład, który pokazuje, jak uruchomić istniejącą aplikację aparatu, aby przechwycić obraz i wyświetlić wynik w postaci mapy bitowej.
Aby poeksperymentować z tym przykładem, musisz uruchomić go na rzeczywistym urządzeniu, na którym obsługiwana jest kamera.
| Kroki | Opis |
|---|---|
| 1 | Użyjesz Android Studio IDE do stworzenia aplikacji na Androida i nadaj jej nazwę Camera w com.example.sairamkrishna.myapplication. |
| 2 | Zmodyfikuj plik src / MainActivity.java, aby dodać kod intencji w celu uruchomienia aparatu. |
| 3 | Zmodyfikuj plik XML układu res / layout / activity_main.xml |
| 4 | Dodaj uprawnienie Aparat i uruchom aplikację i wybierz działające urządzenie z systemem Android, zainstaluj na nim aplikację i sprawdź wyniki. |
Poniżej znajduje się zawartość zmodyfikowanego pliku głównego działania src/MainActivity.java.
package com.example.sairamkrishna.myapplication;
import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.provider.Settings;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
public class MainActivity extends AppCompatActivity {
public static final int MY_PERMISSIONS_REQUEST_CAMERA = 100;
public static final String ALLOW_KEY = "ALLOWED";
public static final String CAMERA_PREF = "camera_pref";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
if (getFromPref(this, ALLOW_KEY)) {
showSettingsAlert();
} else if (ContextCompat.checkSelfPermission(this,
Manifest.permission.CAMERA)
!= PackageManager.PERMISSION_GRANTED) {
// Should we show an explanation?
if (ActivityCompat.shouldShowRequestPermissionRationale(this,
Manifest.permission.CAMERA)) {
showAlert();
} else {
// No explanation needed, we can request the permission.
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.CAMERA},
MY_PERMISSIONS_REQUEST_CAMERA);
}
}
} else {
openCamera();
}
}
public static void saveToPreferences(Context context, String key, Boolean allowed) {
SharedPreferences myPrefs = context.getSharedPreferences(CAMERA_PREF,
Context.MODE_PRIVATE);
SharedPreferences.Editor prefsEditor = myPrefs.edit();
prefsEditor.putBoolean(key, allowed);
prefsEditor.commit();
}
public static Boolean getFromPref(Context context, String key) {
SharedPreferences myPrefs = context.getSharedPreferences(CAMERA_PREF,
Context.MODE_PRIVATE);
return (myPrefs.getBoolean(key, false));
}
private void showAlert() {
AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
alertDialog.setTitle("Alert");
alertDialog.setMessage("App needs to access the Camera.");
alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, "DONT ALLOW",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
finish();
}
});
alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "ALLOW",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
ActivityCompat.requestPermissions(MainActivity.this,
new String[]{Manifest.permission.CAMERA},
MY_PERMISSIONS_REQUEST_CAMERA);
}
});
alertDialog.show();
}
private void showSettingsAlert() {
AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
alertDialog.setTitle("Alert");
alertDialog.setMessage("App needs to access the Camera.");
alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, "DONT ALLOW",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
//finish();
}
});
alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "SETTINGS",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
startInstalledAppDetailsActivity(MainActivity.this);
}
});
alertDialog.show();
}
@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
switch (requestCode) {
case MY_PERMISSIONS_REQUEST_CAMERA: {
for (int i = 0, len = permissions.length; i < len; i++) {
String permission = permissions[i];
if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
boolean
showRationale =
ActivityCompat.shouldShowRequestPermissionRationale(
this, permission);
if (showRationale) {
showAlert();
} else if (!showRationale) {
// user denied flagging NEVER ASK AGAIN
// you can either enable some fall back,
// disable features of your app
// or open another dialog explaining
// again the permission and directing to
// the app setting
saveToPreferences(MainActivity.this, ALLOW_KEY, true);
}
}
}
}
// other 'case' lines to check for other
// permissions this app might request
}
}
@Override
protected void onResume() {
super.onResume();
}
public static void startInstalledAppDetailsActivity(final Activity context) {
if (context == null) {
return;
}
final Intent i = new Intent();
i.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
i.addCategory(Intent.CATEGORY_DEFAULT);
i.setData(Uri.parse("package:" + context.getPackageName()));
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
i.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
i.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
context.startActivity(i);
}
private void openCamera() {
Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
startActivity(intent);
}
}Poniżej będzie treść res/layout/activity_main.xml file-
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">
</RelativeLayout>Poniżej będzie treść res/values/strings.xml aby zdefiniować jedną nową stałą
<resources>
<string name="app_name">My Application</string>
</resources>Poniżej znajduje się domyślna zawartość AndroidManifest.xml -
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.sairamkrishna.myapplication" >
<uses-permission android:name="android.permission.CAMERA" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.example.sairamkrishna.myapplication.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>Spróbujmy uruchomić Twoją aplikację. Zakładam, że podłączyłeś swoje rzeczywiste urządzenie mobilne z systemem Android do komputera. Aby uruchomić aplikację z Android Studio, otwórz jeden z plików aktywności projektu i kliknij
Wybierz swoje urządzenie mobilne jako opcję, a następnie sprawdź swoje urządzenie mobilne, które otworzy aparat i wyświetli następujący ekran -
