Home | History | Annotate | Download | only in components 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.server.telecom.components;
     18 
     19 import com.android.server.telecom.CallIntentProcessor;
     20 import com.android.server.telecom.TelecomSystem;
     21 
     22 import android.app.Activity;
     23 import android.content.Context;
     24 import android.content.Intent;
     25 import android.os.Bundle;
     26 import android.os.PowerManager;
     27 import android.os.UserHandle;
     28 import android.os.UserManager;
     29 import android.telecom.Log;
     30 import android.telecom.TelecomManager;
     31 
     32 // TODO: Needed for move to system service: import com.android.internal.R;
     33 
     34 /**
     35  * Activity that handles system CALL actions and forwards them to {@link CallIntentProcessor}.
     36  * Handles all three CALL action types: CALL, CALL_PRIVILEGED, and CALL_EMERGENCY.
     37  *
     38  * Pre-L, the only way apps were were allowed to make outgoing emergency calls was the
     39  * ACTION_CALL_PRIVILEGED action (which requires the system only CALL_PRIVILEGED permission).
     40  *
     41  * In L, any app that has the CALL_PRIVILEGED permission can continue to make outgoing emergency
     42  * calls via ACTION_CALL_PRIVILEGED.
     43  *
     44  * In addition, the default dialer (identified via
     45  * {@link TelecomManager#getDefaultPhoneApp()} will also be granted the ability to
     46  * make emergency outgoing calls using the CALL action. In order to do this, it must call
     47  * startActivityForResult on the CALL intent to allow its package name to be passed to
     48  * {@link UserCallActivity}. Calling startActivity will continue to work on all non-emergency
     49  * numbers just like it did pre-L.
     50  */
     51 public class UserCallActivity extends Activity implements TelecomSystem.Component {
     52 
     53     @Override
     54     protected void onCreate(Bundle bundle) {
     55         super.onCreate(bundle);
     56         PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
     57         PowerManager.WakeLock wakelock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
     58                 "UserCallActivity");
     59         wakelock.acquire();
     60 
     61         Log.startSession("UCA.oC");
     62         try {
     63             // TODO: Figure out if there is something to restore from bundle.
     64             // See OutgoingCallBroadcaster in services/Telephony for more.
     65             Intent intent = getIntent();
     66             verifyCallAction(intent);
     67             final UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
     68             final UserHandle userHandle = new UserHandle(userManager.getUserHandle());
     69             // Once control flow has passed to this activity, it is no longer guaranteed that we can
     70             // accurately determine whether the calling package has the CALL_PHONE runtime permission.
     71             // At this point in time we trust that the ActivityManager has already performed this
     72             // validation before starting this activity.
     73             // Create a new instance of intent to avoid modifying the
     74             // ActivityThread.ActivityClientRecord#intent directly.
     75             // Modifying directly may be a potential risk when relaunching this activity.
     76             new UserCallIntentProcessor(this, userHandle).processIntent(new Intent(intent),
     77                     getCallingPackage(), true /* hasCallAppOp*/, false /* isLocalInvocation */);
     78         } finally {
     79             Log.endSession();
     80             wakelock.release();
     81         }
     82         Log.i(this, "onCreate done");
     83         finish();
     84     }
     85 
     86     private void verifyCallAction(Intent intent) {
     87         if (getClass().getName().equals(intent.getComponent().getClassName())) {
     88             // If we were launched directly from the CallActivity, not one of its more privileged
     89             // aliases, then make sure that only the non-privileged actions are allowed.
     90             if (!Intent.ACTION_CALL.equals(intent.getAction())) {
     91                 Log.w(this, "Attempt to deliver non-CALL action; forcing to CALL");
     92                 intent.setAction(Intent.ACTION_CALL);
     93             }
     94         }
     95     }
     96 
     97     @Override
     98     public TelecomSystem getTelecomSystem() {
     99         return TelecomSystem.getInstance();
    100     }
    101 }
    102