安卓官方开发指南

Building Apps with Multimedia

Managing Audio Playback

控制音量和播放
- Audio Stream：安卓系统为不同的用途维护了不同的audio stream，便于用户控制不同类型声音的音量
- music
- alarm
- notification
- 来电话
- system sound
- 打电话过程中的声音
- DTMF tones
- 通过设置setVolumeControlStream()，系统将在Activity/Fragment仍在界面上时，自动响应设备的音量操作键，增大或减小设置类型媒体的音量
- 当用户通过耳机等外设，按下播放控制按键时，例如：播放/暂停、上一曲/下一曲，系统将发送一个action为android.intent.action.MEDIA_BUTTON的广播，如下BroadcastReceiver可以响应处理这一广播（需要在AndroidManifest.xml中声明）：
```
public class RemoteControlReceiver extends BroadcastReceiver {
   @Override
   public void onReceive(Context context, Intent intent) {
       if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
           KeyEvent event = (KeyEvent)intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
           if (KeyEvent.KEYCODE_MEDIA_PLAY == event.getKeyCode()) {
               // Handle key press.
           }
       }
   }
}
```

Managing Audio Focus

请求/释放audio focus

AudioManager am = mContext.getSystemService(Context.AUDIO_SERVICE);
...

// Request audio focus for playback
int result = am.requestAudioFocus(afChangeListener,
                               // Use the music stream.
                               AudioManager.STREAM_MUSIC,
                               // Request permanent focus.
                               AudioManager.AUDIOFOCUS_GAIN);

if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
   am.registerMediaButtonEventReceiver(RemoteControlReceiver);
   // Start playback.
}

...
// Abandon audio focus when playback complete    
am.abandonAudioFocus(afChangeListener);

requestAudioFocus的最后一个参数可以设为AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK，用于请求短暂的audio focus，允许其他app在失去audio focus时继续播放音乐（但应该降低音量）

监听audio focus状态改变

OnAudioFocusChangeListener afChangeListener = new OnAudioFocusChangeListener() {
  public void onAudioFocusChange(int focusChange) {
      if (focusChange == AUDIOFOCUS_LOSS_TRANSIENT
          // Pause playback
      } else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
          // Resume playback 
      } else if (focusChange == AudioManager.AUDIOFOCUS_LOSS) {
          am.unregisterMediaButtonEventReceiver(RemoteControlReceiver);
          am.abandonAudioFocus(afChangeListener);
          // Stop playback
      }
  }
};

响应临时失焦且允许重音的情形

OnAudioFocusChangeListener afChangeListener = new OnAudioFocusChangeListener() {
  public void onAudioFocusChange(int focusChange) {
      if (focusChange == AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK) {
          // Lower the volume
      } else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
          // Raise it back to normal
      }
  }
};

检查声音播放设备

if (audioManager.isBluetoothA2dpOn()) {
  // A2DP audio routing to the Bluetooth headset
} else if (audioManager.isSpeakerphoneOn()) {
  // Adjust output for Speakerphone.
} else if (audioManager.isWiredHeadsetOn()) {
  // Adjust output for headsets
} else if (audioManager.isBluetoothScoOn()) {
  // SCO is used for communications
} else { 
  // If audio plays and noone can hear it, is it still playing?
}

一旦耳机/蓝牙耳机断开连接，系统将继续使用默认设备（扬声器）播放，同时系统会发送一个AudioManager.ACTION_AUDIO_BECOMING_NOISY广播，可以通过以下代码进行响应

private class BroadcastReceiver myNoisyAudioStreamReceiver = new BroadcastReceiver() {
  @Override
  public void onReceive(Context context, Intent intent) {
      if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intent.getAction())) {
          // Pause the playback
      }
  }
};

private void startPlayback() {
  registerReceiver(myNoisyAudioStreamReceiver, new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY));
}

private void stopPlayback() {
  unregisterReceiver(myNoisyAudioStreamReceiver);
}

Capturing Photos

使用已有相机APP拍照

声明使用相机的feature，注意，并非权限，便于google play等应用商店确定设备是否可以安装本应用

<manifest ... >
   <uses-feature android:name="android.hardware.camera" android:required="true" />
   ...
</manifest>

也可以设置required为false，手动检查设备是否有相机：packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)
发送Intent调起已有相机APP拍照，发送Intent之前需要检查是否有其他APP可以响应此Intent，如没有却调用了startActivity，将会抛出异常
```
static final int REQUEST_IMAGE_CAPTURE = 1;

private void dispatchTakePictureIntent() {
   Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
   if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
       startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
   }
}
```
在发送takePictureIntent之前，可以手动设置要照片要保存的位置takePictureIntent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, imageFileUri);，拍照成功返回之后，可以直接访问该uri。

获取拍照结果缩略图

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
   if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
       Bundle extras = data.getExtras();
       Bitmap imageBitmap = (Bitmap) extras.get("data");
       mImageView.setImageBitmap(imageBitmap);
   }
}

获取完整照片
照片保存在外置存储卡的公开区域，需要声明权限，WRITE_EXTERNAL_STORAGE包含了READ_EXTERNAL_STORAGE权限，目录路径通过Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)函数获得

<manifest ...>
   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
   ...
</manifest>

如果要保存在APP私有目录下，API 18之后，将不用声明该权限，目录路径通过context.getExternalFilesDir(Environment.DIRECTORY_PICTURES)函数获得，app访问自己对应的该目录，从API 19起，将不需要任何权限，但是访问其他APP对应的目录时，需要WRITE_EXTERNAL_STORAGE/READ_EXTERNAL_STORAGE权限，该目录不一定任何时候都可以访问，也不具备安全性

<manifest ...>
   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
                   android:maxSdkVersion="18" />
   ...
</manifest>

拍照设置保存文件

String mCurrentPhotoPath;

private File createImageFile() throws IOException {
   // Create an image file name
   String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
   String imageFileName = "JPEG_" + timeStamp + "_";
   File storageDir = Environment.getExternalStoragePublicDirectory(
           Environment.DIRECTORY_PICTURES);
   File image = File.createTempFile(
       imageFileName,  /* prefix */
       ".jpg",         /* suffix */
       storageDir      /* directory */
   );

   // Save a file: path for use with ACTION_VIEW intents
   mCurrentPhotoPath = "file:" + image.getAbsolutePath();
   return image;
}

static final int REQUEST_TAKE_PHOTO = 1;

private void dispatchTakePictureIntent() {
   Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
   // Ensure that there's a camera activity to handle the intent
   if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
       // Create the File where the photo should go
       File photoFile = null;
       try {
           photoFile = createImageFile();
       } catch (IOException ex) {
           // Error occurred while creating the File
           ...
       }
       // Continue only if the File was successfully created
       if (photoFile != null) {
           takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT,
                   Uri.fromFile(photoFile));
           startActivityForResult(takePictureIntent, REQUEST_TAKE_PHOTO);
       }
   }
}

加入Gallery，当保存路径设为context.getExternalFilesDir(type)时，将无法加入Gallery

private void galleryAddPic() {
   Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
   File f = new File(mCurrentPhotoPath);
   Uri contentUri = Uri.fromFile(f);
   mediaScanIntent.setData(contentUri);
   this.sendBroadcast(mediaScanIntent);
}

获取压缩后的图片，用于显示在ImageView上

private void setPic() {
   // Get the dimensions of the View
   int targetW = mImageView.getWidth();
   int targetH = mImageView.getHeight();

   // Get the dimensions of the bitmap
   BitmapFactory.Options bmOptions = new BitmapFactory.Options();
   bmOptions.inJustDecodeBounds = true;
   BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
   int photoW = bmOptions.outWidth;
   int photoH = bmOptions.outHeight;

   // Determine how much to scale down the image
   int scaleFactor = Math.min(photoW/targetW, photoH/targetH);

   // Decode the image file into a Bitmap sized to fill the View
   bmOptions.inJustDecodeBounds = false;
   bmOptions.inSampleSize = scaleFactor;
   bmOptions.inPurgeable = true;

   Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
   mImageView.setImageBitmap(bitmap);
}

使用已有相机应用录制视频，与拍照类似，需要发送的Intent初始化为Intent takeVideoIntent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);，onActivityResult返回的intent的data数据，就是录制视频的Uri，intent.getData()。

直接使用相机

Camera API

权限

<uses-permission android:name="android.permission.CAMERA" />  
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-feature android:name="android.hardware.camera" android:required="true" />

在onResume中inflate SurfaceView，动态添加到layout中，在onPause中停止预览，移除SurfaceView，以解决界面onPause后再onResume就无法预览的问题。在SurfaceView的surfaceCreated回调中打开相机，开始预览

@Override
public void surfaceCreated(SurfaceHolder holder) {
   mSurfaceHolder = holder;
   initPreview(holder);
}

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

}

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
   releaseResources();
}

@Override  
protected void onResume() {  
   mSurfaceView = (SurfaceView) LayoutInflater.from(getActivity())
           .inflate(R.layout.ui_surface_view, null);
   flContainer.addView(mSurfaceView, 0);
   isPreview = true;
   SurfaceHolder mSurfaceHolder = mSurfaceView.getHolder();
   mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
   mSurfaceHolder.setKeepScreenOn(true);
   mSurfaceHolder.addCallback(this);
}

打开相机，开始预览

private boolean initPreview(SurfaceHolder holder) {
   int mSupportVideoFormat[] = {ImageFormat.NV21, ImageFormat.YV12};
   try {
       cameraid = getCameraId(isFrontCamera);
       mCamera = Camera.open(cameraid);
   } catch (Exception e) {
       e.printStackTrace();
       return false;
   }

   if (mCamera == null) {
       ToastUtils.toastResId(R.string.error_init_player_fail);
       return false;
   }

   // change to portrait record
   setCameraDisplayOrientation(cameraid, mCamera);
   try {
       mCamera.setPreviewDisplay(holder);
   } catch (IOException e) {
       ToastUtils.toastResId(R.string.error_IO_error);
       e.printStackTrace();
       return false;
   }
   Camera.Parameters parameters = mCamera.getParameters();
   parameters.setPreviewSize(width, height);
   parameters.setPictureSize(width, height);
   if (isLightOn) {
       parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
   }

   int actualFormat = 0;
   List<Integer> list = parameters.getSupportedPreviewFormats();
   for (int format : mSupportVideoFormat) {
       for (Integer i : list) {
           Timber.i("startVideoCapture " + "suport format:" + i);
           if (format == i.intValue()) {
               actualFormat = format;
               break;
           }
       }
       if (actualFormat != 0) {
           break;
       }
   }
   if (actualFormat == 0) {
       Timber.e("startVideoCapture" + " no suport format be found");
       return false;
   }
   parameters.setPreviewFormat(actualFormat);// ImageFormat.YV12
   try {
       mCamera.setParameters(parameters);
       mCamera.startPreview();
   } catch (Exception e) {
       e.printStackTrace();
       return false;
   }

   return true;
}

Google Camera2 Sample，简版

权限

<uses-sdk  
   android:minSdkVersion="21"  
   android:targetSdkVersion="21" />  
<uses-permission android:name="android.permission.CAMERA" />  
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  
<uses-feature android:name="android.hardware.camera2.full" />

layout

<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: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="com.example.camera2te.MainActivity" >

   <TextureView
       android:id="@+id/texture"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:layout_alignParentStart="true"
       android:layout_alignParentTop="true" />
</RelativeLayout>

设置TextureView回调，在onSurfaceTextureAvailable回调中打开相机

private TextureView.SurfaceTextureListener mSurfaceTextureListener = new TextureView.SurfaceTextureListener(){  

   @Override  
   public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {  
       Log.e(TAG, "onSurfaceTextureAvailable, width="+width+",height="+height);  
       openCamera();  
   }  

   @Override  
   public void onSurfaceTextureSizeChanged(SurfaceTexture surface,  
           int width, int height) {  

   }  

   @Override  
   public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {  
       return false;  
   }  

   @Override  
   public void onSurfaceTextureUpdated(SurfaceTexture surface) {  

   }  

};

@Override  
protected void onResume() {  
   ...  
   mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
   ...
}

打开相机，在相机回调中开始预览

private void openCamera() {  
   CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE); 
   try {  
       String cameraId = manager.getCameraIdList()[0];  
       CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);  
       StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);  
       mPreviewSize = map.getOutputSizes(SurfaceTexture.class)[0];  

       manager.openCamera(cameraId, mStateCallback, null);  
   } catch (CameraAccessException e) {  
       e.printStackTrace();  
   }
}  

private CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {  

   @Override  
   public void onOpened(CameraDevice camera) {    
       mCameraDevice = camera;  
       startPreview();  
   }  

   @Override  
   public void onDisconnected(CameraDevice camera) {  

   }  

   @Override  
   public void onError(CameraDevice camera, int error) {  

   }  

};

开启预览

protected void startPreview() {  
   if(null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {  
       Log.e(TAG, "startPreview fail, return");  
       return;  
   }  

   SurfaceTexture texture = mTextureView.getSurfaceTexture();  
   if(null == texture) {  
       Log.e(TAG,"texture is null, return");  
       return;  
   }  

   texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());  
   Surface surface = new Surface(texture);  

   try {  
       mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);  
   } catch (CameraAccessException e) {  

       e.printStackTrace();  
   }  
   mPreviewBuilder.addTarget(surface);  

   try {  
       mCameraDevice.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() {  

           @Override  
           public void onConfigured(CameraCaptureSession session) {  

               mPreviewSession = session;  
               updatePreview();  
           }  

           @Override  
           public void onConfigureFailed(CameraCaptureSession session) {  

               Toast.makeText(MainActivity.this, "onConfigureFailed", Toast.LENGTH_LONG).show();  
           }  
       }, null);  
   } catch (CameraAccessException e) {  

       e.printStackTrace();  
   }  
}  

protected void updatePreview() {  
   if(null == mCameraDevice) {  
       Log.e(TAG, "updatePreview error, return");  
   }  

   mPreviewBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);  
   HandlerThread thread = new HandlerThread("CameraPreview");  
   thread.start();  
   Handler backgroundHandler = new Handler(thread.getLooper());  

   try {  
       mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, backgroundHandler);  
   } catch (CameraAccessException e) {  

       e.printStackTrace();  
   }  
}

Printing Content, >= API 19

打印图片

PrintHelper photoPrinter = new PrintHelper(getActivity());
photoPrinter.setScaleMode(PrintHelper.SCALE_MODE_FIT);
Bitmap bitmap = BitmapFactory.decodeResource(getResources(),
      R.drawable.droids);
photoPrinter.printBitmap("droids.jpg - test print", bitmap);

ScaleMode
- SCALE_MODE_FIT：等比例缩放图片，使之可以在打印区域内显示
- SCALE_MODE_FILL：充满打印区域，上下/左右可能会有部分内容无法打印

打印HTML文档

private WebView mWebView;

private void doWebViewPrint() {
  // Create a WebView object specifically for printing
  WebView webView = new WebView(getActivity());
  webView.setWebViewClient(new WebViewClient() {

          public boolean shouldOverrideUrlLoading(WebView view, String url) {
              return false;
          }

          @Override
          public void onPageFinished(WebView view, String url) {
              Log.i(TAG, "page finished loading " + url);
              createWebPrintJob(view);
              mWebView = null;
          }
  });

  // Generate an HTML document on the fly:
  String htmlDocument = "<html><body><h1>Test Content</h1><p>Testing, " +
          "testing, testing...</p></body></html>";
  webView.loadDataWithBaseURL(null, htmlDocument, "text/HTML", "UTF-8", null);

  // Keep a reference to WebView object until you pass the PrintDocumentAdapter
  // to the PrintManager
  mWebView = webView;
}

private void createWebPrintJob(WebView webView) {

  // Get a PrintManager instance
  PrintManager printManager = (PrintManager) getActivity()
          .getSystemService(Context.PRINT_SERVICE);

  // Get a print adapter instance
  PrintDocumentAdapter printAdapter = webView.createPrintDocumentAdapter();

  // Create a print job with name and adapter instance
  String jobName = getString(R.string.app_name) + " Document";
  PrintJob printJob = printManager.print(jobName, printAdapter,
          new PrintAttributes.Builder().build());

  // Save the job object for later status checking
  mPrintJobs.add(printJob);
}

自定义文档（内容）打印：
- 可以先把View画到bitmap中，然后打印bitmap
- 也可以实现PrintDocumentAdapter，打印自定义内容

Building Apps with Multimedia

安卓官方开发指南

Building Apps with Multimedia

results matching ""

No results matching ""