1. UNNotificationContent Extension
2. UNNotificationService Extension

Now, Let’s discuss each in detail below:

1. UNNotificationContent Extension

Overview

The protocol UNNotificationContentExtension provides the entry point for a Notification Content app extension, which displays a custom interface for your app’s notifications. You can implement this protocol in the custom UIViewController subclass that you use to present your interface. By having this type of extension, you can improve the way your notifications are presented, possibly by adding custom colors and branding or by incorporating media and other dynamic content into your notification interface.

To integrate a Notification Content app extension, add a Notification Content extension target to the Xcode project containing your app. Extension’s Info.plist file comes mostly configured. Identifically, the NSExtensionPointIdentifier key is set to the value com.apple.usernotifications.content-extension and the NSExtensionMainStoryboard key is set to the name of the project’s storyboard file. However, the NSExtensionAttribute key contains a dictionary of additional keys and values, some of which you must configure manually:

• UNNotificationExtensionCategory. (Required Key) The value of this key is a string or an array of strings. Every string contains the identifier of a category declared by the app using the UNNotificationCategory class.
• UNNotificationExtensionInitialContentSizeRatio. (Required) The value of this key is a floating-point number that represents the initial size of your view controller’s view expressed as a ratio of its height to its width. This value is used by the system to set the initial size of the view controller while your extension is loading. E.g., a value of 0.5 results in a view controller whose height is half its width. After your extension loads, you can change the size of your view controller.
• UNNotificationExtensionDefaultContentHidden. (Optional) This key has a Boolean value. When you set to true, the system displays only your custom view controller in the notification interface. When you set to false, the system displays the default notification content in addition to your view controller’s content. The Dismiss button and Custom action buttons are always displayed, regardless of this setting. The default value of this key is false.
• UNNotificationExtensionOverridesDefaultTitle. (Optional) This key has a Boolean value. When you set to true, the system uses the title property of your view controller as the title of the notification. When you set to false, the system sets the notification’s title to the name of your app. The default value of this key is false.

You can include multiple Notification Content extensions in your app’s bundle. When a notification arrives, the system checks the UNNotificationExtensionCategory key of each extension’s Info.plist file and launches the extension that supports the notification’s category. At that time, the system loads your extension, instantiates and configures your view controller, and calls the view controller’s didReceive(_:) method. You must implement that method and use it to configure your notification interface. The method may be called multiple times if new notifications arrive while your view controller is visible.

If the notification category includes custom actions, the system automatically adds action buttons to your notification interface; do not create those buttons yourself. If you implement the optional didReceive(_:completionHandler:) method, the system calls that method to respond to any selected actions. If your view controller does not implement that method, the system delivers the selected action to your app for handling.

Media Interface

To support the playback of audio or video from your interface, implement the mediaPlayPauseButtonType property and return the type of button you want. You must also implement the mediaPlayPauseButtonFrame property and provide a frame rectangle for your button. The system draws the button for you and handles all user interactions with it, calling the mediaPlay() and mediaPause() methods of this protocol at appropriate times so that you can start and stop playback.

If you start or stop playback of your media file programmatically, call the mediaPlayingStarted() and mediaPlayingPaused() methods of the current NSExtensionContext object. The extensionContext property of your view controller object contains a reference to the extension context object.

Methods, Constants and Variables of UNNotificationContent Extension

• func didReceive(_ notification: UNNotification)
  This method will be called to deliver notifications to your Notification Content app extension. Using this method you can configure the contents of your view controller or incorporate content from a new notification. This method can be called multiple times while your view controller is visible. Identically, it is called again when a new notification arrives whose threadIdentifier value matches the thread identifier of the notification already being displayed. You can adjust the size of your view controller’s view after it is onscreen to accommodate new content. When changing the size, change only the height. (Values for width are ignored.) You can then add subviews to fill the additional space with your content.
• optional func didReceive(_ response: UNNotificationResponse, completionHandler completion: @escaping (UNNotificationContentExtensionResponseOption) -> Void) Use this method when you want your view controller to handle actions selected by the user. Use your implementation to perform the associated task and then execute the completion block. If you go with this method, you must handle all actions defined in all categories managed by your Notification Content app extension. If you do not implement this method, the system notifies your app when the user selects an action.
• optional var mediaPlayPauseButtonType: UNNotificationContentExtensionMediaPlayPauseButtonType { get } Use this property when you want the system to display a media playback button in your notification interface. Return a constant indicating the type of button you want. The system assumes the value none for this property if you do not implement this property.
• optional var mediaPlayPauseButtonFrame: CGRect { get }
  If you give support to the playback of media directly from your notification interface, implement this property and use it to return a non-empty rectangle specified in the coordinate system of your view controller’s view. A button is drawn by the system in the provided rectangle that lets the user play and pauses your media content. The system does the drawing of the button for you and calls the mediaPlay() and mediaPause() methods in response to user interactions. You can put this button anywhere in your view controller’s view. If you do not implement this property, the system does not draw a media playback button.
• NSCopying optional var mediaPlayPauseButtonTintColor: UIColor { get } If you use the mediaPlayPauseButtonFrame property, you can also implement this property and use it to specify the tint color to apply to the button. If you do not implement this property, the system uses a default color for the tint color.
• optional func mediaPlay() If you implement the mediaPlayPauseButtonFrame property, implement this method and use it to begin the playback of your media. Do not call this method yourself. The system calls it in response to user interactions with the media playback button.
• optional func mediaPause() If you implement the mediaPlayPauseButtonFrame property, implement this method and use it to stop the playback of your media. Do not call this method yourself. The system calls it in response to user interactions with the media playback button.
• UNNotificationContentExtensionMediaPlayPauseButtonType
  • UNNotificationContentExtensionMediaPlayPauseButtonTypeNone
    No media button. Specify this option when you do not want a media button. This is the default option.
  • UNNotificationContentExtensionMediaPlayPauseButtonTypeDefault
    A standard play/pause button. This button is always visible. When this button is tapped, its appearance changes between the play and pause icons and triggers the appropriate play and pause actions.
  • UNNotificationContentExtensionMediaPlayPauseButtonTypeOverlay
    A play/pause button with partially transparent that is layered on top of your media content. When playback begins, the button disappears. Tapping the button again pauses playback and displays the play button again.
• UNNotificationContentExtensionResponseOption
  • UNNotificationContentExtensionResponseOptionDoNotDismiss
    Do not dismiss the notification interface. The content extension handles the selected action.
  • UNNotificationContentExtensionResponseOptionDismiss
    This will dismiss the notification interface. The content extension handles the selected action.
  • UNNotificationContentExtensionResponseOptionDismissAndForwardAction
    In this, dismiss the notification interface and forward the notification to the app. Select this option when you want the app to respond to the action or handle it.

Let’s have a look on example.

With the new project open in Xcode, navigate to File > New > Target in the menu bar. From the dialog that appears, select the iOS > Application Extension > Notification Content extension type:

Name your extension whatever you require and click Finish:

If a popup appears requesting you to initiate your new scheme, click the Activate button to set it up for debugging:

You will now have a new folder with the name of your extension in the Xcode File Navigator for your project. This folder contains the following files:

• NotificationViewController.swift, this contains the NotificationViewController class (a UIViewController subclass) for your custom interface. Initially , Xcode also automatically makes this class conform to the required protocol from the UserNotificationUI framework.
• MainInterface.storyboard, this is a storyboard file containing a single view controller. This interface will be shown when a user interacts with your notification. By Default , Xcode automatically links this interface up to the NotificationViewController class so that does not have to be done manually.
• Info.plist, this contains many important details about your extension. By opening up this file, you will see it contains a lot of items. The only one you need to worry about, however, is the NSExtensiondictionary which contains the following:

  

• You can see that Xcode automatically links your notification content extension to the correct system extension point, com.apple.usernotifications.content-extension, and storyboard interface file, MainInterface. Inside the NSExtensionAttributes sub-dictionary, there are two attributes you must define:
• UNNotificationExtensionCategory, this is a string value identical to the notification category you want to display the custom interface for. In your Info.plist file, change this value to name which you are going to use in notification payload.
• UNNotificationExtensionInitialContentSizeRatio, this is a number between 0 and 1 defining the aspect ratio of your custom interface. The value 1, which is default, tells the system that your interface has a total height equal to its width. With 0.5 value, for example, would result in an interface with a height equal to half of its total width. It is required to note that the height of your interface can be changed dynamically when it is loaded. The value defined in the Info.plist is just an estimate number so that the system can display a better-looking animation.

To create the interface, open up your MainInterface.storyboard file. First thing to do is, select the view controller and in the Attributes inspector, change its height to be equal to its width.
Secondly, change the background colour of the main view to white. At last, change the existing label’s text colour property to black and the text size to 96.

Now write the code to fire local notification in your app delegate as below. Make sure it’s category is same you defined Info.plist file.

{
  "aps":{
          "alert":{
                    "title":"Imagica",
                    "body":"Let’s feel thrill on ride."
           },
           "badge":42,
           "sound":"default",
           "category":"imagica.category",
           "mutable-content":1
        },
          "rides":["Amusement Park", "Family Theme Park"],
          "subtitle":"Your ride is ready",
}
 
// Update this property as you manipulate the content
 
var bestAttemptContent: UNMutableNotificationContent?
 
override func didReceive(_ request: UNNotificationRequest
, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
  if let copy = request.content.mutableCopy() as? UNMutableNotificationContent {
    bestAttemptContent = copy
 
    // Edit properties of copy
    let userInfo = bestAttemptContent.userInfo as! [String:Any]
 
    //change the content to the rides
    if let rideEntry = userInfo["rides"] {
      let rides = rideEntry as! [String]
      var body = ""
      for item in rides {
        body += item + "\n "
      }
      bestAttemptContent.body = body
    }
    contentHandler(bestAttemptContent)
    }
}

The local notification that created by the starter project includes a custom number in the notification’s userInfo property, and this is what we are going to display in the custom interface. For this, replace your NotificationViewController class’s didReceive(_:) method with the following:

func didReceive(_ notification: UNNotification) {
    if let number = notification.request.content.userInfo["customNumber"] as? Int {
        label?.text = "\(number)"
    }
}

Now run the project and move app to background once launched. After 30 sec you will get notification and drag that notification and you will get below interface.

2. UNNotificationService Extension

Overview

This UNNotificationServiceExtension class provides the entry point for a Notification Service app extension, which lets you customize the content of a remote notification before it is delivered to the user. This Notification Service app extension does not present any UI of its own. Instead of, it is launched on demand when a notification of the appropriate type is delivered to the user’s device. You can use this extension to modify the notification’s content or download content related to the extension. E.g., you could use the extension to decrypt an encrypted data block or to download images associated with the notification.

You do not create instances of the UNNotificationServiceExtension class yourself. Instead of, the Xcode template for a Notification Service Extension target contains a subclass for you to modify. By using this methods of that subclass you can implement your app extension’s behavior. Once remote notification for your app is received, the system loads your extension and calls its didReceive(_:withContentHandler:) method only when both of the following conditions are met:

• The remote notification is configured to display an alert.
• The remote notification’s payload includes the mutable-content key with the value set to 1.

Note: Silent notifications or those that only play a sound or badge the app’s icon, cannot be modified.

The didReceive(_:withContentHandler:) method is used to performs the main work of your extension. You can use that method to make any changes to the notification’s content. This method has a limited amount of time to perform its task and execute the provided completion block. If your method fail to do in time, the system calls the serviceExtensionTimeWillExpire() method to give you one last chance to submit your changes. If you do not update the notification content before time expires, the system displays the original content.

For any of your app extension, you deliver a Notification Service app extension class as a bundle inside your app. By using the template provided by Xcode configures the Info.plist file automatically for this app extension type. Specifically, it sets the value of the NSExtensionPointIdentifier key to com.apple.usernotifications.service and sets the value of the NSExtensionPrincipalClass key to the name of your UNNotificationServiceExtension subclass.

Methods of UNNotificationService Extension

• func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void)

  You must need to Override this method and use it to modify the UNNotificationContent object that was delivered with the notification. At some point during your integration, execute the contentHandler block and pass it your modified content. If you do not want to modify the content, call the contentHandler block with the original content from the request parameter.

  If you want to modify any of the content , you can do it from the original request. You can customize the content for the current user or replace it altogether. By using this method you can download images or movies and add them as attachments to the content. You can also modify the alert text as long as you do not remove it. The system ignores your modifications and delivers the original notification content, If the content object does not contain any alert text.

  This extension has a limited amount of time (no more than 30 seconds) to modify the content and execute the contentHandler block. If your block is not executed in a timely manner, the system calls your extension’s serviceExtensionTimeWillExpire() method to give you one last chance to execute the block. If you fail to do that, the system presents the notification’s original content to the user.

  Check below code that shows an example implementation of this method:

  Suppose the payload of aps is as below.

  {
    "aps":{
            "alert":{
                      "title":"Imagica",
                      "body":"Let’s feel thrill on ride."
             },
             "badge":42,
             "sound":"default",
             "category":"imagica.category",
             "mutable-content":1
          },
            "rides":["Amusement Park", "Family Theme Park"],
            "subtitle":"Your ride is ready",
  }
  
  // Update this property as you manipulate the content
  
  var bestAttemptContent: UNMutableNotificationContent?
  
  override func didReceive(_ request: UNNotificationRequest
  , withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
    if let copy = request.content.mutableCopy() as? UNMutableNotificationContent {
      bestAttemptContent = copy
  
      // Edit properties of copy
      let userInfo = bestAttemptContent.userInfo as! [String:Any]
  
      //change the content to the rides
      if let rideEntry = userInfo["rides"] {
        let rides = rideEntry as! [String]
        var body = ""
        for item in rides {
          body += item + "\n "
        }
        bestAttemptContent.body = body
      }
      contentHandler(bestAttemptContent)
      }
  }
  

• func serviceExtensionTimeWillExpire()

  If your didReceive(_:withContentHandler:) method takes to long to execute its completion block, the system calls this method on a separate thread to give you one last chance to execute the block. This method is used to execute the block as quickly as possible. Doing so might mean providing some fallback content. E.g., if your extension is still downloading an image file with the intent of attaching it to the notification’s content, you might update the notification’s alert text to indicate that an image is being downloaded. The system displays the notification’s original content,if you fail to execute the completion block from the didReceive(_:withContentHandler:) method in time.

  var contentHandler: ((UNNotificationContent) -> Void)?
   
  // Update this property as you manipulate the content
  var bestAttemptContent: UNMutableNotificationContent?
   
  override func serviceExtensionTimeWillExpire() {
      if let contentHandlerObj = contentHandler, let bestAttemptContent =  bestAttemptContent {
          contentHandlerObj (bestAttemptContent)
      }
  }
  

Limitation

The important thing to consider when using a notification service extension is the conditions under which the extension will operate.

First one, your extension will only be launched for notifications which are configured to show on-screen alerts to the user. It means that any silent notifications (like the ones used to update app badges) will not trigger your extension.

Secondly, the incoming notification’s aps dictionary within its payload must include the mutable-contentkey with a value of 1.

The post Notification Extensions in iOS Apps appeared first on TatvaSoft Blog.

Reason behind the Limitation

This behaviour change is introduced to improve the battery life and the usage of RAM when apps are in the background, which can result in better user experiences. Moreover, this change is introduced because background services are also unfavourable for application performance. When more than one app is performing any task in the background then it will affect the performance of the application which is running in the foreground. Also if some additional apps or services are running in background puts extra load on the device system which again affects UI.

How Does It Effects On Android App Development?

There could be so many reasons we are using background services or broadcasts like to keep your data updated as per the server changes or UI changes on the particular event or may be for performing some long-running task. For whatever reason we are using background task it will be affected by development. Overcoming this limitation will be majorly helpful for client application development for any Android app development company.

What are the Changes?

• The ‘startService()’ method now throws an ‘IllegalStateException’. If we try to use this method in the case of background services it will not allow.
• For starting foreground service we now have the ‘Context.startForegroundService()’ method. This method can be called even when the app is in the background but the app must call that service’s method ‘startForeground()’ within five seconds after the service is created.

How to Handle Limitation?

There are three ways to overcome from this limitation, namely –

1. Job Scheduler
2. FCM
3. Foreground Service

Now let’s discuss each in detail below:

1. Job Scheduler

Job Scheduler is introduced in API 21 for performing background tasks. This allows us to move away from background service implementation and just to focus on execution. Using this we can run scheduled services and the Android system will set all the services from different apps in one group or set and execute them together at a particular time. The reason behind this is to reduce the amount of time the phone’s CPU and radio wakes up by batching the tasks together. This will consume less battery. The only drawback of Job Scheduler is it can only be run API 21 or above.

Advantages:

• Once the device is connected to a power supply, the task should be done.
• Tasks that require network availability or a Wi-Fi reachability.
• The task that is not user-facing or critical.
• Where the timing is not critical the Tasks should be running on a regular basis as the batch

Implementation:
To implement a Job, extend the JobService class and implement the onStartJob and onStopJob. If the job scheduler fails for some reason, return true from on the onStopJob to restart the job. The method onStartJob is performed in the main thread, if you start asynchronous processing in this method, return True otherwise False.

The new JobService must be registered in the Android manifest with the BIND_JOB_SERVICE permission.

And now, below is the snippet to schedule the job.

ComponentName serviceComponent = new ComponentName(context,TestJobService.class);
JobInfo.Builder builder = new JobInfo.Builder(0,serviceComponent);
builder.setMinimumLatency(1 * 1000);
builder.setOverrideDeadline(3 * 1000);
JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
jobScheduler.schedule(builder.build());

2. FCM

Here to overcome the drawback of Job Scheduler we can use FCM, FCM is supported from API Level 19.

When services are running in the background there are some scenarios which allow applications to temporarily run in the background as if they were running in the foreground. Applications will be included on these scenarios in situations when they are:

• To trigger high priority FCM/GCM notification
• To perform SMS/MMS delivery
• Capture Notification Action

We can send FCM notifications to trigger a service of our application. For this, using High Priority messages allows our application to be added to a service in those scenarios which allows our services to run as if they were in the foreground because High Priority message will be received even when the system is in Doze Mode so by doing this we can start our service to update our application’s data if our application was not running in the background or killed. In FCM we must remember to set messages to High Priority otherwise messages will be received when the device screen is turned back on or during the Doze maintenance window.

3. Foreground Services

Another simple way is to make service foreground. Sometimes running a service carrying out the task which may require user interaction or monitoring the task which is being executed. Like users downloading some data, using a timer to perform some time-based operation or receiving navigational directions from your application, these are the cases where we can use foreground service. When running foreground services use a persistent notification to acknowledge the user aware that they are currently running.

Implementation:
Before Android Oreo, if you wish to create a foreground service, you mostly start a background service by calling startService(). Then we can start our foreground service by assigning an ongoing notification using the startForeground() method. But from Android Orio startService() will not be working nowadays, so for starting foreground service we must use startForegroundService() method, this method is static and belongs to the class NotificationManager. This method is the same as creating background service and promoting it to the foreground service combine. The method itself is called startService(), but with the contract that startForeground () will be called. The main difference with using this method as compared to startService () is that we can call it at any time, even if our application is not currently in the foreground.

Using the startForegroundService() method, passing an intent for our service task to be carried out. These tricks will create our background service that we must immediately promote to the foreground. Within use of this service, we need to create a notification to be displayed for our foreground service. This must be of at least higher priority or Low so that is shown to the user on screen — if the priority is set to PRIORITY_MIN then the notification will not be displayed to the user. And then, android app developers can call startForeground(id, notification) from within the service — this will promote our service to the foreground.

Conclusion

These limitations applied to the background service might lead to some difficulties in development but these will definitely provide extended battery life and also lower RAM usage. So ultimately it will make your applications smooth and your user happy.

The post Handle Background Service Limitations of Oreo appeared first on TatvaSoft Blog.

The Navigation Architecture Component is designed to have a single activity with multiple Fragments. The Activity hosts a Navigation Graph. If the app has multiple Activities each Activity hosts its own Navigation Graph.

Principles of Navigation

1. The app should have a fixed starting destination.
2. A stack is used to represent the navigation state of an app.
3. The Up button never exits the app.
4. Up and Back are equivalent within the app’s task.
5. Deep linking to a destination or navigating to the same destination should yield the same stack.

Implement Navigation

• Add the Google repository to the projects build.gradle(Project level).

  allprojects {
     repositories {
         google()
         jcenter()
     }
  }
  

• Add the following dependencies to the app or module build.gradle(App level).
• Implementation ‘android.arch.navigation:navigation-fragment-ktx:1.0.0-alpha01‘

Components of Navigation

1. Navigation Graph: Blueprint of the Navigation destinations and actions that link them.
2. Destinations: List of all the fragments. One can define arguments, actions and deep link URLs to these addresses.

   

3. Host: The parent activity and entry point for the application logic.
4. Actions: Specifies the destination fragment, transitions to that fragment, arguments and pop behavior.

   

Navigation Graph XML

• With Android Studio 3.2 android app programmers can now add a Navigation Resource File. Right click on the res directory and select New -> Android resource file. Select a title for the file and select Navigation from the Resource type dropdown.
• Now one will have a new file with a new root element type

Navigation Host Fragment

In the MainActivity layout one have to add a fragment as NavHost and define where the NavHostFragment finds the navigation graph.

Defining Destinations

• Back in the Navigation Graph android app developers can add new destinations. One can switch between Design and Text. If one choose Design then can see a three columns layout.
• One can now add existing Fragments/Activities to the Navigation Graph (Icon on the top left) or add a new blank destination.

Perform Navigation

• To perform a navigation one have to define an action (right side of the Design View). One will use a simple navigation without transitions and params (In the next Part one will create more complex transactions).
• Therefore, one will have to select the source fragment, afterwards click on the + next to the Actions and choose Add Action. Now one will see an Add Action Wizard. One have to choose a destination (the id will be generated for us) and click Add.
• One can now navigate with the NavigationController.navigate(id: Int) method. To retrieve the NavigationController one have to call findNavController() in the Source Fragment.

The findNavController method is an extension function in Kotlin.

detailButton.setOnClickListener { view ->
       view.findNavController().navigate(R.id.action_list_to_detail)
}

Deep links

• One can provide Explicit Deep Links for the destinations from the application widget or notification with the help of a Pending Intent as follows,

  PendingIntent deeplink = Navigation.findNavController(v).createDeepLink()
  .setDestination(R.id.android)       
  .setArguments(args)     
  .createPendingIntent();
  

• One can also provide Implicit Deep Links to redirect a URL to a particular destination of the app with the help of <deepLink> tag as,

Purpose or Use Cases of Navigation

1. Fragment Transaction takes place asynchronously. Though it is generally a good thing, it might lead to a data race when another piece of code tries to read the state of the fragment, those painful IllegalStateException.
2. Guidelines state that Deep Linked screen on back pressed will have to lead back to their previous logical screen. And one have to handle that manually.
3. For android development company to test the android app gets much easier and simpler.
4. arguments is much safer (save from refractor).

The post Navigation Controller – An Android StoryBoard appeared first on TatvaSoft Blog.

Beyond tap or pinch gestures, 3D Touch caters something fascinating, where users can press app icon and access immediate actions provided, can view recent or frequents in widget or press notifications and perform quick functionalities of it or press brief views to get detail preview. 3D Touch, an extension dimension of Multi touch accelerated access to ios applications.

Even though, 3D Touch is implemented in individual iPhone app development, it is not just the software based. Flabbergast? Have a brief look how 3D Touch is also hardware-based execution and not just software-based.

Tech Appended For 3D Touch

With other hardware improvements like Apple A9 chip with embedded M9 motion coprocessor, 12MP rear-facing iSight camera, second-generation Touch ID in iPhones 6S and iPhone 6S plus, Apple also showcased major transfiguration in screen – making phone compatible to 3D Touch technology.

The transfiguration is adding up 4-layered sensitive display which responds based on the type of touch – Light, Medium and Firm. Four layers, based on their response system-level application developed reverts, incorporates –

• Retina HD Display with 3D Touch: It helps in detecting the finger pressure applied by the user.Retina HD display on backlight is attached with the capacitive pressure sensors.
• Capacitive Pressure Sensors:When cover glass is pressed,sensors measures the pressure from the space between cover glass and backlight,accordingly it will respond back.
• Taptic Engine:For elegant haptic feedback engine,Taptic Engine is used.It is capable enough to precisely respond to each measure of pressures on the screen.

Subject to such changes in hardware, 3D Touch technology is executed in iOS App Development. Apps are upgraded accordingly to make it compatible to 3D Touch.

Implementing 3D Touch in iPhone App Development

iOS 9 or later supports 3D Touch. To start implementing 3D Touch, it is necessary to download Xcode projects namely – ApplicationShortcuts, ViewControllerPreviews and TouchCanvas. 3D Touch comes with three categories – Home screen Quick Actions, Peek and Pop and Pressure and Intensity Sensitivity

Home Screen Quick Actions

Tap an app icon on Home screen and access static or dynamic quick actions. UIApplicationShortcutItems array is used to define static or dynamic quick action in iPhone application development Info.plist file.

Dynamic quick actions come up with additional shortcuts in app’s shared UIApplication, so add it in shortcutItems property. Define dynamic quick actions using UIApplicationShortcutItem, UIMutableApplicationShortcutItem, and UIApplicationShortcutIcon classes.

Peek and Pop

To support view and preview, iOS 9 SDK includes support in UIViewController class. registerForPreviewing(with:sourceView) method registers the view controller to participate in 3D Touch preview (peek) and commit (pop) behaviors. UIViewControllerPreviewing Protocol Reference justifies interface for 3D Touch-enabled view controller. UIViewControllerPreviewingDelegate Protocol Reference is used to define peek and if screen is hard pressed, it shows preview of the view. Below is mentioned the demo snippet for peek and pop actions.

let contactName = "Robert Garero"
        var icon: UIApplicationShortcutIcon? = nil
        self.requestForAccess { (true) in
            let predicate = CNContact.predicateForContacts(matchingName: contactName)
            let contacts = try? CNContactStore().unifiedContacts(matching: predicate, keysToFetch: [])
            if let contact = contacts?.first {
                icon = UIApplicationShortcutIcon(contact: contact)
            }
        }
 
        let type = "com.company.app.sendChatTo"
        let subtitle = "Send a chat"
        let shortcutItem1 = UIApplicationShortcutItem(type: type, localizedTitle: contactName, localizedSubtitle: subtitle, icon: icon, userInfo: nil)
 
        let shortcutitems = [shortcutItem1]
        UIApplication.shared.shortcutItems = shortcutitems
let type = “com.company.app.sendChatTo”
let subtitle = “Send a chat”
let shortcutItem1 = UIApplicationShortcutItem(type: type, localizedTitle: contactName, localizedSubtitle: subtitle, icon: icon, userInfo: nil)

let shortcutitems = [shortcutItem1]
UIApplication.shared.shortcutItems = shortcutitems

The messages previewed are not marked as read. Also, if arrow is available at the top – means additional power shortcuts like reply, save or add to read later are available. Even like or dislike can be done and replies or comment can also be mentioned.

Pressure and Intensity Sensitivity

UITouch class’s properties force and maximumPossibleForce are used to detect the touch pressure and accordingly, the app responds. iPhone app developers use this class for performing touch effective event like dragging icon or keyboard text selection or tapping a link or image and adding to read later list.

All above this, 3D Touch accessibility is optional for a user. User can disable 3D Touch. User can also set 3D Touch sensitivity from Light, Medium and Firm.

3D Touch indeed came up with a revolution in mobile app development. Right from built-in apps to social media apps and image editing apps have adopted this technique in their iPhone applications. 3D Touch refined the basic features and let users have quick access to the apps.

The post 3D Touch is a New Generation of Gestures appeared first on TatvaSoft Blog.

To ensure that these apps consistently perform well for all users, regardless of the device or network, programmers must focus on providing a uniform experience across all devices and operating systems, and hence they must undergo mobile app testing.

In this post, we will go over the importance of mobile testing and some recommended best practices for large-scale mobile app testing. Let us begin now.

1. What is Mobile App Testing?

Mobile app testing is a process that all applications designed for small devices must undergo to ensure they meet a certain level of quality. Before an application is released on the App Store, it undergoes testing. Any issues discovered during this process are reported to the development team for prompt resolution, preventing them from impacting the application’s performance after launch.

On several operating systems, the App Store is known by different names. For all Google or Android-based devices, the App Store is referred to as the Play Store for instance. On iOS devices, it is the App Store.

Here is what a Quora user says about mobile app testing.

2. Benefits of Mobile App Testing

Mobile app testing is a crucial part of the development process, and testers ensure that it’s done right. Knowing the advantages of mobile app testing can help you initiate this important process without missing any opportunities. The following lists some benefits of mobile app testing:

2.1 Ensure User Interface (UI)/ User Experience (UX) Usability

App testing allows testers to assess programs from the end-user’s perspective. By modeling normal user behavior and assessing the app’s appearance and functionality, they evaluate the usability and user-friendliness. Through mobile app testing on various devices and screen sizes, testers identify any logical flow and navigation issues. This clarifies the UI/UX usability of the mobile app.

2.2 Proper Functioning

The goal of QA is to ensure that an app runs without errors. QAs verify whether an application meets specific performance criteria —that is, different load circumstances, changing networks, etc. Every QA team chooses for itself whether it will be testing using emulators or actual devices. 

When choosing between these two, you should not put all your bets on one card. In the early phases of app development, simulators can be very helpful; however, before release, it is important to consider actual devices to ensure the flawless performance of your app. Based on experience, the best approach is to combine both methods and incorporate a device cloud for testing.

2.3 Reduced Development Costs

Early in the development process, catching and correcting errors is less expensive than addressing them after the final product is released. Proper testing saves companies both time and money in the long term by identifying and fixing issues before they become significant problems.

2.4 Prompt Bug Identification

Many mobile apps are prone to bugs, which can compromise performance and lead to losses. Bug discovery often occurs in the later phases of mobile development, potentially resulting in time and data losses. One of the key advantages of mobile application testing is the increased likelihood of promptly identifying and avoiding errors that could compromise functionality.

Businesses can suffer significant losses due to late bug discovery or the inability to detect issues early. A small coding mistake can undermine all your hard work put into designing and developing a mobile app. Such errors can ultimately have a damaging impact on performance.

Mobile application testing addresses this issue through its approach. Early bug identification, facilitated by automated mobile testing, ensures the development of bug-free mobile applications. As a result of thorough testing, bugs are fixed quickly.

Automated mobile testing, unlike manual testing, can help you identify the source of bugs. With this kind of data, businesses can rapidly spot preventive strategies to stop similar bugs from reappearing. For an enterprise, having a robust testing system is crucial for early identification and prevention of issues that could disrupt the functionality of your mobile application.

2.5 Faster App Deployment

Using the Agile development method, automated testing helps to provide quick app development that produces amazing outcomes and raises the return on investment. Automation testing shortens the life cycle of app development, therefore enabling faster app launch.

3. Types of Mobile App Testing

You can run different types of mobile app tests to ensure that the developed product meets the necessary quality standards and functions up to expectations. They comprise availability, scalability, utility, and security.

Let’s discuss a few of them:

3.1 Functional Testing

Functional testing is about assessing the features and functionalities of an application to ensure they perform as intended. Throughout all the user flows, testers examine essential features to identify and fix any unintentional functional flaws that may arise during the software development process.

3.2 Performance Testing

Performance testing allows testers to evaluate how mobile apps perform under high stress and in a low or unavailable internet environment. It ensures that the apps operate as expected in demanding circumstances. This type of testing enables simple analysis of the load time, battery and memory consumption, speed of data transmission, and recovery capacity of the software.

3.3 Exploratory Testing

The exploratory testing makes scaling and automation more challenging. Still, finding original problems depends on it. One can incorporate it with other testing approaches in an orderly approach.

Here is what a Twitter user says about Exploratory testing.

Exploratory testing includes questioning things outside the scope of your ticket if you notice something seems wrong. Even if you're not sure having a conversation about it is so important! If it looks wrong to you, customers may be thinking the same!

— Bailey Hanna (@BaileyHanna) May 29, 2018

3.4 Security Testing

Another key type of mobile app testing aimed at identifying and addressing application vulnerabilities is security testing. The app should be able to survive any unplanned failures and various types of attacks.

3.5 Usability Testing

In terms of how easy and natural something is to use, usability testing, also called user experience testing, goes further than functional testing. It emphasizes on trying to replicate the actual experience of a client using the app to locate locations where they could get caught or struggle to use the app as intended, or just generally have an unpleasant experience.

4. How to Perform Mobile App Testing

A thorough, step-by-step testing method is essential to ensure that all of the app’s features, usefulness, and security meet the required standards before it can be released. Let’s go into more depth about this all-encompassing process:

4.1 Preparation and Strategy Formulation

The first step is to make a plan for the testing, which includes working out what needs to be done, which devices will be tested, what kind of app will be tested, and what cases need to be run. At this point, you need to decide whether the tests will be done manually or automatically. Automation is helpful for tests that need to be run on multiple devices, tests with known results, and unit testing.

4.2 Identification of Essential Testing Types

To ensure that the mobile app functions correctly on all Android and iOS devices, it is tested manually, automatically, and in the cloud. This method helps find bugs and ensure the app does what it’s supposed to do.

4.3 Design of Test Script and Test Case

Test cases, which are lists of steps to follow for testing a specific app, are very important to the process. Test scripts are used for automated testing, while test cases are used for manual testing. These are made based on the events in the mobile game.

4.4 Setup of Testing Environment

The codes and devices used to test mobile apps constitute the testing environment. The setup of this environment depends on the specific app being tested. Properly configuring the test environment is important for the functional testing process to go well.

4.5 Manual and Automated Testing

Both manual and automated tests are used to check the app’s main features. This step is crucial for identifying bugs and fixing them so that the application works better.

4.6 Usability and User Interface Testing

Usability testing is conducted on the app to ensure it is user-friendly, beneficial, and meets users’ needs. UI testing makes sure that the app has a simple, easy-to-understand layout that users can easily use and explore.

4.7 Compatibility Testing

Make sure that the app works perfectly on all mobile devices, computer screens, and operating systems.

4.8 Performance Testing

Testing how well the app works by switching between 2G, 3G, and WIFI connections, sharing files, checking battery life, and so on.

4.9 Security Testing

The goal of security testing is to see how safe your app is. It also looks at the risk of app hackers, viruses, app security, and getting private data without permission.

4.10 Usability and Beta Testing

Usability testing and beta testing are important components of mobile app testing because they help find bugs that are difficult to detect before the app is released to the market. To get responses from real users, you can start usability testing while the site is still being designed. It lets writers show off possible features and cut down on the list of ones that users have already dismissed.

Once the mobile app is ready, beta testing is done so that coders can get feedback before it is released to the public.

4.11 Feedback Integration and Iterative Testing

Feedback integration and ongoing software testing are beneficial for both mobile and real devices. These options, like others, can have an effect on both your automated and manual testing teams by providing new perspectives on user experiences and insights regarding your product. Additionally, this feedback can be used as part of your overall strategy.

4.12 End-to-End Testing Before Final Release

Once all the testing steps are done, an end-to-end testing sprint is carried out to make sure the server and backend of the app work as planned. If any problems are found, they are fixed, and the end-to-end run can be done again.

The rise of smartphones and the apps that go with them has sped up the digital revolution, which has changed our world in ways we are only now starting to understand. However, to make sure these mobile apps reach their full potential, thorough mobile app testing is essential but often overlooked.

5. Challenges In Mobile Testing

It’s not easy to test mobile apps. It requires a lot of time and work to test apps on all devices. This part of the mobile app testing lesson is all about the problems and challenges that testers might run into while they are testing mobile apps.

5.1 Different Data Connections

We all know that mobile devices connect to various network speeds (3G, 4G, 5G, etc.) based on their WiFi and location. The users should test their apps through different network conditions to make sure they work properly, even on slow or unstable connections.

5.2 Device Fragmentation

Device fragmentation means that there are a lot of different gadgets on the market at any given time. The number of devices that are running an app at any given time keeps going up every year. The testing teams are in charge of making sure that their apps work on a variety of browsers and running systems, such as iOS and Android devices.

5.3 Constant OS Updates

Operating systems undergo upgrades all the time, especially when it comes to phones. Each update can bring about changes that affect how well an app works and could cause bugs or problems with other apps.

5.4 Resource Availability

Native mobile app testing requires a significant investment of time, devices, and occasionally, human resources. This can put a lot of stress on smaller development teams.

5.5 Varied Network Conditions

Individuals can access apps over different types of networks, such as 3G, 4G, and high-speed Wi-Fi. It can be hard to make sure that the app works perfectly in these situations.

5.6 Adding Third-Party Features

A lot of apps use features that come with devices, like SMS, or third-party services for things like tracking and reporting crashes. The testers should make sure that these services work well with their apps. This job could add to the work that needs to be done to test the mobile app properly.

6. Best Practices for Mobile Application Testing

You now know about the difficulties and types of testing that are carried out. Here are some best practices that your QA team can use to make sure that the testing process doesn’t miss any important details.

• Before you start trying mobile apps, you should make sure you fully understand how they work. It will assist you in creating proper test cases and ensure that test coverage metrics are met.
• Before you start the test, you should have a clear testing plan that includes goals, scope, and methods. Running the test with each test process in the chain will be helpful.
• Real devices are the best way to test your mobile app because they make it easy to find bugs that you might not be able to see on apps and models.
• In mobile app testing, testing for user experience is very important. You should be careful when checking the app’s accessibility, ease of use, and speed to make sure it works well for everyone.
• You need to ensure the mobile app works properly in real-time by testing it in various places, with different time zones, varied network circumstances, and on low battery alerts.
• Apps for phones should still work properly after the OS is updated. So testers must keep watching out for updates and make sure the app stays up to date so it works right.
• A test-driven development method should be used to test mobile apps early and often. It makes sure that tests are run early on and at different points in the project so that an effective mobile app can be developed.
• Automation can make testing a lot easier and take a lot less time. To make sure your app works well on all devices, you should use automatic testing tools to check its features and speed.

7. Conclusion

Mobile phones are now an important part of everyone’s daily life. Its many uses become clearer as it grows. A lot of different types of people use it for shopping, entertainment, and other things. Because of this, it is a very competitive setting where even the smallest mistake in your application can cost you. This makes testing mobile apps very important.

To sum up, testing mobile apps is an important part of creating them. By discovering the different types of mobile apps, testing methods, and best practices, you can make sure that your app works well and gives users a great experience. Working with professionals like TatvaSoft can help your mobile app be even better and more reliable. This will help it do well in the very competitive app market. 

FAQ

1. How do I manually test an app?

Follow these steps to manually test an app:

• Make a concise plan.
• Test on several different devices and settings.
• Pick challenging-to-understand use cases.
• Use exploratory and ad hoc testing.
• Keep track of the results of the testing. 

2. What is the best tool for mobile testing?

These are some of the tools you can consider for mobile app testing:

• Espresso
• XCUI Test
• Robotium
• Flutter
• Robot Framework

The post The Importance of Mobile App Testing appeared first on TatvaSoft Blog.

Emergence of Enterprise Mobility

With the latest shift in work habits and companies providing the freedom to employees to work from anywhere, most of companies are relying on Mobility to improve their employee’s productivity. A drastic increase in devices managed in the enterprise is observed at 72% from 2014 to 2015, and it is increasing year-on-year.

Let us look at the Definition of Enterprise Mobility as per WhatIs.com: “Enterprise mobility is the trend towards a shift in work habits, with more employees working out of the office and using mobile devices and cloud services to perform business tasks.”

Since the advent of BYOD (Bring Your Own Device) trend in the workplace, more and more companies are making corporate data available on Mobile Devices. This helps an employee to transfer data from a PC to a cloud storage service to access that data from a personal Tablet or Mobile at the client site.

Incredible Mobility Trends and Facts

Below are some latest Mobility trends which highlight the evolving nature of work and emphasize the need for organizations to both empower and manage employee mobility in order to meet security, agility and productivity demands as mentioned in Citrix Mobile Analytics Report:

• 61% of workers report working outside the office at least part of the time
• 3+ devices are used daily by an employee for work activities
• iOS dominates the enterprise market and is the leading mobile platform in nearly every industry vertical
• Device diversity is greatest in EMEA, where mobile devices used to work are typically corporate issued
• 90% of organizations deploy passcode enforcement, the most common device level policy
• Top blacklisted apps include Dropbox and Mail while top whitelisted apps include PDF and Notes

Nowadays, demand of mobile device usage is countless at different workplaces. For example, salespeople take tablets instead of laptops when they travel, doctors use a handheld device to check Electronic Medical Records and Clinical Applications right from the patient’s bedside. Similarly, in the retail sector, the sales person can conduct on-spot inventory check for customers and also collect payments without returning to the counter. Through the above examples, we could realize how Enterprise Mobility is enabling more efficient, effective, collaborative and flexible work styles.

Seeing the recent trends on how mobile devices are being used at the workplace, these devices are quickly becoming the new desktop. There has been an explosion of mobile devices being used for work, whether authorized or not, the organization has to enable and protect users no matter what type of device they choose to work with – a PC, notebook, tablet, or smartphone. Many employees utilize mobile devices to access organizational systems and critical business applications, both on and off the corporate network. These protected systems contain sensitive data that if exposed could result in data security breaches and revenue loss for an organization.

An unsecured mobile device can easily compromise the corporate network, jeopardizing the productivity benefits gained from enabling mobile access in the first place.

Major Mobile Security Concerns

Lets explore some of the major mobile security concerns.

1. Device Loss

There has been many high profile data breaches wherein an employee carelessly forgets his tablet or smartphone in a cab or at a restaurant that puts the sensitive data, such as corporate intellectual property or customer information at risk.

2. Application Security

Simple mobile apps that request too many privileges and often granted gains access of all device data. This has been responsible for leaked corporate contacts, calendar items and even the location of certain executives has put the company at a competitive disadvantage. Trojan affected applications also appear to function normally, but secretly upload sensitive data to a remote server.

3. Device Data Leakage

Most corporate access privileges on mobile devices remain limited to calendar items and email, new mobile business applications can tap into a variety of sources if the enterprise accepts the risks. Too much corporate information on a mobile device draws the attention of cyber criminals who can target both the device and the back-end systems they tap into with mobile malware.

4. Malware Attacks

Majority of Mobile Malware comes in the form of SMS Trojans designed to charge device owners’ premium text messages. Experts say Android devices face the biggest threat, but other platforms can attract financially motivated cybercriminals if they adopt NFC (Near Field Communications) and other mobile payment technologies.

5. Device Theft

Smartphone theft is a very common problem smartphone owners such as iPhone or high-end android device faces. The danger of corporate data, such as account credentials and access to email, falling into the hands of a tech-savvy thief, makes the issue a major threat.

Key Concerns for Mobile Strategies

Following are three big questions on which business leaders should focus on to round out their Mobile strategies, and those are:

• What type of data will make employees more productive by having mobile access to it?
• What are the security implications of that access?
• And what model makes more sense for providing that access?

A company should adopt a holistic strategy that covers corporate approved App access, namely, Enterprise Content Management and Enterprise Mobile Management that meet their security needs.

Key Strategies to Secure Enterprise Mobility

Today, more and more businesses rely on Enterprise Mobility with requirements to safeguard their business data, provide secure mobile access to business documents and keep mobile devices safe from threats. Mobile technology has made the network security challenge much bigger and more diverse. Use of mobile devices and apps has introduced a wide range of new attack vectors and new data security challenges for IT.

Ways to Secure These Threats

1. Installing Anti-Malware Software

New Malware is constantly made to attack iOS and android operating systems. Any employee who uses a mobile device to access internet should prior install or update antimalware software on his or her smartphone or tablet.

2. Keeping an Eye Out for Bad Apps

To streamline business processes and enhance employee productivity, the enterprise should provide the workforce with relevant mobile apps. Also, a policy has to be put in place to determine which apps can be download or access via. the corporate network.

3. Remote Locking and Erasing Feature

All the Enterprise Mobility devices should have an app that allows an employee to remotely lock and erase the entire data on the device in case of a theft or loss.

4. Strong Passwords

All the mobility devices should be secured with a complex password and changed on frequent intervals. Employees should be educated about security threats and the damage they can cause from a weak password strength. Many modern mobile devices include local security options such as built-in biometrics, such as fingerprint scanners, facial recognition, and voiceprint recognition and so forth to render better security.

5. Updating

Ask employees to get the habit of updating apps as soon as they are prompted. Software updates can include fixes to new vulnerabilities and exploited security gaps.

6. Protection and Encryption of Data

Encrypt sensitive information with strong keys as soon as it is acquired. Data at rest in storage, servers, and devices, as well as data on the wire (and over the air) should remain encrypted as they are used, stored or moved and eventually decrypted only by the intended receiver.

7. Data Backup

To ensure data restoration after a device is damaged, wiped or lost, take advantage of data backup capabilities supported by each mobile OS. Native backup capabilities typically include writing backup files to a laptop or desktop and routinely backing up data to cloud storage (e.g., Apple iCloud, Google Drive). Mobile Application developers should take advantage of backup capabilities, but should be aware of the risk of doing so.

8. Performing Regular Audits

At least once a year, companies and organizations should hire a reputable security testing firm to audit their mobile security and conduct vapt on the mobile devices they use. Such firms can also help with remediation and mitigation of any issues they discover, as will sometimes be the case. This way companies can better protect themselves from the latest threats.

Conclusion

Mobile devices today are powerful computing devices and a gateway to countless productivity tools, entertainment resources, and social networking channels. No wonder, mobile devices and app adoption have swept enterprises rapidly, even greater than many enterprises realize.

As Uncle Ben said to Peter Parker before he became Spiderman, “With great power comes great responsibility.” The same is true with Enterprise Mobility. When implemented properly, it can bestow great benefits to an organization; but to enjoy those benefits it requires attention to a broad set of security measures.

The post How to Combat Threats of Implementing Enterprise Mobility? appeared first on TatvaSoft Blog.